Subversion Repositories SmartDukaan

Rev

Rev 5713 | Rev 5874 | 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 
 
5713 rajveer 381 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 382 
    """
383 
    Parameters:
384 
     - providerId
385 
     - orderIds
5713 rajveer 386 
     - awbs
5676 rajveer 387 
    """
388 
    pass
389 
 
4910 phani.kuma 390 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 391 
    """
4910 phani.kuma 392 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
393 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 394 
 
3064 chandransh 395 
    Parameters:
759 chandransh 396 
     - providerId
4910 phani.kuma 397 
     - pickupDetails
759 chandransh 398 
    """
399 
    pass
400 
 
4910 phani.kuma 401 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 402 
    """
403 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 404 
 
1113 chandransh 405 
    Parameters:
406 
     - providerId
407 
    """
408 
    pass
409 
 
1132 chandransh 410 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
411 
    """
412 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
413 
    the name of the receiver.
414 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 415 
 
1132 chandransh 416 
    Parameters:
417 
     - providerId
418 
     - deliveredOrders
419 
    """
420 
    pass
421 
 
4910 phani.kuma 422 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 423 
    """
4910 phani.kuma 424 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 425 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 426 
 
1135 chandransh 427 
    Parameters:
428 
     - providerId
429 
     - returnedOrders
430 
    """
431 
    pass
432 
 
4910 phani.kuma 433 
  def getRTOrders(self, providerId):
434 
    """
435 
    Returns a list of orders that were returned by courier.
436 
 
437 
    Parameters:
438 
     - providerId
439 
    """
440 
    pass
441 
 
1246 chandransh 442 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
443 
    """
444 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 445 
 
1246 chandransh 446 
    Parameters:
447 
     - providerId
448 
     - undeliveredOrders
449 
    """
450 
    pass
451 
 
4910 phani.kuma 452 
  def getNonDeliveredOrdersbyCourier(self, providerId):
453 
    """
454 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
455 
 
456 
    Parameters:
457 
     - providerId
458 
    """
459 
    pass
460 
 
461 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
462 
    """
463 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
464 
 
465 
    Parameters:
466 
     - providerId
467 
     - local_connected_orders
468 
    """
469 
    pass
470 
 
471 
  def getOrdersNotLocalConnected(self, providerId):
472 
    """
473 
    Returns a list of orders that were picked up or shipped but pending local connection.
474 
 
475 
    Parameters:
476 
     - providerId
477 
    """
478 
    pass
479 
 
480 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
481 
    """
482 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
483 
 
484 
    Parameters:
485 
     - providerId
486 
     - destination_city_reached_orders
487 
    """
488 
    pass
489 
 
490 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
491 
    """
492 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
493 
 
494 
    Parameters:
495 
     - providerId
496 
     - first_atdl_orders
497 
    """
498 
    pass
499 
 
1408 ankur.sing 500 
  def getUndeliveredOrders(self, providerId, warehouseId):
501 
    """
502 
    Returns the list of orders whose delivery time has passed but have not been
503 
    delivered yet for the given provider and warehouse. To get a complete list of
504 
    undelivered orders, pass them as -1.
505 
    Returns an empty list if no such orders exist.
3431 rajveer 506 
 
1408 ankur.sing 507 
    Parameters:
508 
     - providerId
509 
     - warehouseId
510 
    """
511 
    pass
512 
 
4783 phani.kuma 513 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
514 
    """
515 
    Returns the list of orders whose expected delivery date has passed but have not been
516 
    delivered yet.
517 
    Returns an empty list if no such orders exist.
518 
    """
519 
    pass
520 
 
2536 chandransh 521 
  def toggleDOAFlag(self, orderId):
522 
    """
523 
    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.
524 
    Returns the final flag status.
525 
    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 526 
 
2536 chandransh 527 
    Parameters:
528 
     - orderId
529 
    """
530 
    pass
1886 ankur.sing 531 
 
4712 rajveer 532 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
533 
    """
534 
    Parameters:
535 
     - orderId
536 
     - deliveryTimestamp
537 
     - receiver
538 
    """
539 
    pass
540 
 
5553 rajveer 541 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
542 
    """
543 
    Parameters:
544 
     - orderId
545 
     - deliveryTimestamp
546 
    """
547 
    pass
548 
 
4454 rajveer 549 
  def markOrderDoaRequestReceived(self, orderId):
550 
    """
551 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
552 
 
553 
    Parameters:
554 
     - orderId
555 
    """
556 
    pass
557 
 
558 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
559 
    """
560 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
561 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
562 
 
563 
    Parameters:
564 
     - orderId
565 
     - isAuthorized
566 
    """
567 
    pass
568 
 
4488 rajveer 569 
  def markOrderReturnRequestReceived(self, orderId):
570 
    """
571 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
572 
 
573 
    Parameters:
574 
     - orderId
575 
    """
576 
    pass
577 
 
578 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
579 
    """
580 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
581 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
582 
 
583 
    Parameters:
584 
     - orderId
585 
     - isAuthorized
586 
    """
587 
    pass
588 
 
4579 rajveer 589 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 590 
    """
591 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 592 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
593 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 594 
    For any other status, it returns false.
595 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 596 
 
2536 chandransh 597 
    Parameters:
598 
     - orderId
4579 rajveer 599 
     - providerId
2536 chandransh 600 
    """
601 
    pass
602 
 
4602 rajveer 603 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 604 
    """
4452 rajveer 605 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 606 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
607 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
608 
    	3. Returns true
2591 chandransh 609 
    If the order is in any other status, it returns false.
2536 chandransh 610 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 611 
 
2536 chandransh 612 
    Parameters:
613 
     - orderId
614 
     - pickupNumber
4602 rajveer 615 
     - providerId
2536 chandransh 616 
    """
617 
    pass
618 
 
2764 chandransh 619 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
620 
    """
621 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 622 
 
2764 chandransh 623 
    Parameters:
624 
     - providerId
625 
     - pickupDetails
626 
    """
627 
    pass
628 
 
4910 phani.kuma 629 
  def getDoasNotPickedUp(self, providerId):
630 
    """
631 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
632 
 
633 
    Parameters:
634 
     - providerId
635 
    """
636 
    pass
637 
 
4741 phani.kuma 638 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
639 
    """
640 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
641 
 
642 
    Parameters:
643 
     - providerId
644 
     - pickupDetails
645 
    """
646 
    pass
647 
 
4910 phani.kuma 648 
  def getReturnOrdersNotPickedUp(self, providerId):
649 
    """
650 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
651 
 
652 
    Parameters:
653 
     - providerId
654 
    """
655 
    pass
656 
 
4479 rajveer 657 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 658 
    """
4452 rajveer 659 
    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 660 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 661 
    If the order is in any other state, it returns false.
662 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 663 
 
2591 chandransh 664 
    Parameters:
665 
     - orderId
4479 rajveer 666 
     - receiveCondition
2591 chandransh 667 
    """
668 
    pass
2536 chandransh 669 
 
2591 chandransh 670 
  def validateDoa(self, orderId, isValid):
671 
    """
4452 rajveer 672 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 673 
    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 674 
    If the order is in any other state, it returns false.
675 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 676 
 
2591 chandransh 677 
    Parameters:
678 
     - orderId
679 
     - isValid
680 
    """
681 
    pass
682 
 
4495 rajveer 683 
  def validateReturnProduct(self, orderId, isUsable):
684 
    """
685 
    Parameters:
686 
     - orderId
687 
     - isUsable
688 
    """
689 
    pass
690 
 
2616 chandransh 691 
  def reshipOrder(self, orderId):
692 
    """
4484 rajveer 693 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 694 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 695 
    	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 696 
 
697 
    If the order is in DOA_CERT_VALID state, it does the following:
698 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
699 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 700 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 701 
 
2616 chandransh 702 
    Returns the id of the newly created order.
3431 rajveer 703 
 
2616 chandransh 704 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 705 
 
2616 chandransh 706 
    Parameters:
707 
     - orderId
708 
    """
709 
    pass
2591 chandransh 710 
 
3226 chandransh 711 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 712 
    """
4484 rajveer 713 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 714 
    	1. Creates a refund request for batch processing.
715 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 716 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 717 
 
2616 chandransh 718 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
719 
    	1. Creates a refund request for batch processing.
3226 chandransh 720 
    	2. Cancels the reservation of the item in the warehouse.
721 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 722 
 
3226 chandransh 723 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
724 
    	1. Cancels the reservation of the item in the warehouse.
725 
    	2. Marks the current order as CANCELED.
726 
 
727 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
728 
 
2616 chandransh 729 
    Returns True if it is successful, False otherwise.
3431 rajveer 730 
 
2616 chandransh 731 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 732 
 
2616 chandransh 733 
    Parameters:
734 
     - orderId
3226 chandransh 735 
     - refundedBy
736 
     - reason
2616 chandransh 737 
    """
738 
    pass
739 
 
2690 chandransh 740 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
741 
    """
742 
    Get all return orders created between the from and to dates for the given warehouse.
743 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 744 
 
2690 chandransh 745 
    Parameters:
746 
     - warehouseId
747 
     - fromDate
748 
     - toDate
749 
    """
750 
    pass
2616 chandransh 751 
 
5481 phani.kuma 752 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
753 
    """
754 
    Get all return orders created between the from and to dates.
755 
 
756 
    Parameters:
757 
     - onlyNotProcessed
758 
     - fromDate
759 
     - toDate
760 
    """
761 
    pass
762 
 
2700 chandransh 763 
  def getReturnOrder(self, id):
764 
    """
765 
    Returns the ReturnOrder corresponding to the given id.
766 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 767 
 
2700 chandransh 768 
    Parameters:
769 
     - id
770 
    """
771 
    pass
772 
 
2690 chandransh 773 
  def processReturn(self, returnOrderId):
774 
    """
775 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 776 
 
2690 chandransh 777 
    Parameters:
778 
     - returnOrderId
779 
    """
780 
    pass
781 
 
3451 chandransh 782 
  def updateWeight(self, orderId, weight):
783 
    """
784 
    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 785 
 
3451 chandransh 786 
    Parameters:
787 
     - orderId
788 
     - weight
789 
    """
790 
    pass
791 
 
3469 chandransh 792 
  def changeItem(self, orderId, itemId):
793 
    """
794 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
795 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 796 
 
3469 chandransh 797 
    Parameters:
798 
     - orderId
799 
     - itemId
800 
    """
801 
    pass
802 
 
803 
  def shiftToWarehouse(self, orderId, warehouseId):
804 
    """
805 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
806 
 
807 
    Parameters:
808 
     - orderId
809 
     - warehouseId
810 
    """
811 
    pass
812 
 
4647 rajveer 813 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 814 
    """
815 
    Adds the given delay reason to the given order.
3986 chandransh 816 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 817 
    Raises an exception if no order with the given id can be found.
3469 chandransh 818 
 
3553 chandransh 819 
    Parameters:
820 
     - orderId
821 
     - delayReason
3986 chandransh 822 
     - furtherDelay
4647 rajveer 823 
     - delayReasonText
3553 chandransh 824 
    """
825 
    pass
826 
 
3956 chandransh 827 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
828 
    """
829 
    Marks the COD orders with given AWB nos. as having been processed.
830 
    Updates the captured amount for the corresponding payment.
3553 chandransh 831 
 
3956 chandransh 832 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
833 
    1. There is no order corresponding to an AWB number.
834 
    2. The captured amount for a payment exceeds the total payment.
835 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
836 
 
837 
    Parameters:
838 
     - collectedAmountMap
839 
     - xferBy
840 
     - xferTxnId
841 
     - xferDate
842 
    """
843 
    pass
844 
 
4008 mandeep.dh 845 
  def getTransactionsRequiringExtraProcessing(self, category):
846 
    """
4065 mandeep.dh 847 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 848 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 849 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 850 
 
4008 mandeep.dh 851 
    Parameters:
852 
     - category
853 
    """
854 
    pass
855 
 
856 
  def markTransactionAsProcessed(self, transactionId, category):
857 
    """
858 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 859 
    It essentially deletes the transaction id record for a particular
860 
    processing type category (if present) from DB.
861 
    This is currently used by CRM application.
4008 mandeep.dh 862 
 
863 
    Parameters:
864 
     - transactionId
865 
     - category
866 
    """
867 
    pass
868 
 
4018 chandransh 869 
  def getItemWiseRiskyOrdersCount(self, ):
870 
    """
871 
    Returns a map containing the number of risky orders keyed by item id. A risky order
872 
    is defined as one whose shipping date is about to expire.
873 
    """
874 
    pass
4008 mandeep.dh 875 
 
4295 varun.gupt 876 
  def getOrdersForItemIds(self, itemIds):
877 
    """
878 
    Returns a list of all orders which have items with given id
879 
 
880 
    Parameters:
881 
     - itemIds
882 
    """
883 
    pass
884 
 
4247 rajveer 885 
  def markOrderCancellationRequestReceived(self, orderId):
886 
    """
887 
    Mark order as cancellation request received. If customer sends request of cancellation of
888 
    a particular order, this method will be called. It will just change status of the order
889 
    depending on its current status. It also records the previous status, so that we can move
890 
    back to that status if cancellation request is denied.
4018 chandransh 891 
 
4247 rajveer 892 
    Parameters:
893 
     - orderId
894 
    """
895 
    pass
896 
 
897 
  def markOrderCancellationRequestConfirmed(self, orderId):
898 
    """
899 
    If we decide to to cancel order, CRM will call this method to move the status of order to
900 
    cancellation request confirmed. After this OM will be able to cancel the order.
901 
 
902 
    Parameters:
903 
     - orderId
904 
    """
905 
    pass
906 
 
907 
  def markOrderCancellationRequestDenied(self, orderId):
908 
    """
909 
    If we decide to not to cancel order, we will move the order ro previous status.
910 
 
911 
    Parameters:
912 
     - orderId
913 
    """
914 
    pass
915 
 
4258 rajveer 916 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 917 
    """
4258 rajveer 918 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
919 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 920 
 
921 
    Parameters:
4258 rajveer 922 
     - transactionId
4247 rajveer 923 
    """
924 
    pass
925 
 
4259 anupam.sin 926 
  def refundTransaction(self, transactionId, refundedBy, reason):
927 
    """
928 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
929 
    need to be cancelled
4247 rajveer 930 
 
4259 anupam.sin 931 
    Parameters:
932 
     - transactionId
933 
     - refundedBy
934 
     - reason
935 
    """
936 
    pass
937 
 
4324 mandeep.dh 938 
  def updateShipmentAddress(self, orderId, addressId):
939 
    """
940 
    Updates shipment address of an order. Delivery and shipping date estimates
941 
    etc. are also updated here.
942 
 
943 
    Throws TransactionServiceException in case address change is not
944 
    possible due to certain reasons such as new pincode in address is
945 
    not serviceable etc.
946 
 
947 
    Parameters:
948 
     - orderId
949 
     - addressId
950 
    """
951 
    pass
952 
 
4285 rajveer 953 
  def acceptOrdersForItemId(self, itemId, inventory):
954 
    """
955 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
956 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 957 
 
4285 rajveer 958 
    Parameters:
959 
     - itemId
960 
     - inventory
961 
    """
962 
    pass
963 
 
4369 rajveer 964 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 965 
    """
966 
    Parameters:
967 
     - vendorId
968 
     - itemId
969 
     - quantity
970 
     - estimate
4369 rajveer 971 
     - isReminder
4303 rajveer 972 
    """
973 
    pass
4285 rajveer 974 
 
4369 rajveer 975 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 976 
    """
977 
    Parameters:
978 
     - vendorId
979 
     - itemId
980 
     - quantity
981 
     - estimate
4369 rajveer 982 
     - isReminder
4303 rajveer 983 
    """
984 
    pass
985 
 
4369 rajveer 986 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 987 
    """
988 
    Parameters:
989 
     - vendorId
990 
     - itemId
991 
     - quantity
992 
     - estimate
4369 rajveer 993 
     - isReminder
4303 rajveer 994 
    """
995 
    pass
996 
 
4369 rajveer 997 
  def markOrdersAsTimeout(self, vendorId):
998 
    """
999 
    Parameters:
1000 
     - vendorId
1001 
    """
1002 
    pass
4303 rajveer 1003 
 
4662 rajveer 1004 
  def markOrderAsLostInTransit(self, orderId):
1005 
    """
1006 
    Mark order as LOST_IN_TRANSIT
1007 
 
1008 
    Parameters:
1009 
     - orderId
1010 
    """
1011 
    pass
1012 
 
4386 anupam.sin 1013 
  def getOrderForAwb(self, awb):
1014 
    """
1015 
    Returns the order corresponding to an AWB number
4369 rajveer 1016 
 
4386 anupam.sin 1017 
    Parameters:
1018 
     - awb
1019 
    """
1020 
    pass
1021 
 
4910 phani.kuma 1022 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1023 
    """
4910 phani.kuma 1024 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1025 
 
4506 phani.kuma 1026 
    Parameters:
1027 
     - logistics_provider_id
4910 phani.kuma 1028 
     - order_status_list
4506 phani.kuma 1029 
    """
1030 
    pass
1031 
 
4600 varun.gupt 1032 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1033 
    """
1034 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1035 
 
4600 varun.gupt 1036 
    Parameters:
1037 
     - vendorId
1038 
     - billingDateFrom
1039 
     - billingDateTo
1040 
    """
1041 
    pass
1042 
 
4607 rajveer 1043 
  def getSlippedSippingDateOrders(self, ):
1044 
    pass
1045 
 
4709 rajveer 1046 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1047 
    """
1048 
    Parameters:
1049 
     - cancelDateFrom
1050 
     - cancelDateTo
1051 
    """
1052 
    pass
1053 
 
4600 varun.gupt 1054 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1055 
    """
1056 
    Parameters:
1057 
     - mapAWBAndAmount
1058 
    """
1059 
    pass
1060 
 
4905 varun.gupt 1061 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1062 
    """
1063 
    Parameters:
1064 
     - settlementDate
1065 
     - paymentGatewayId
4905 varun.gupt 1066 
     - referenceId
4600 varun.gupt 1067 
     - serviceTax
1068 
     - otherCharges
1069 
     - netCollection
1070 
    """
1071 
    pass
1072 
 
1073 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1074 
    """
1075 
    Parameters:
1076 
     - settlementId
1077 
     - settlementDate
1078 
     - transactionDateFrom
1079 
     - transactionDateTo
1080 
     - amount
1081 
    """
1082 
    pass
1083 
 
5386 phani.kuma 1084 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1085 
    """
1086 
    Parameters:
5189 varun.gupt 1087 
     - referenceId
1088 
     - isRefund
4600 varun.gupt 1089 
    """
1090 
    pass
1091 
 
5386 phani.kuma 1092 
  def getSettlementForCod(self, orderId, isRefund):
1093 
    """
1094 
    Parameters:
1095 
     - orderId
1096 
     - isRefund
1097 
    """
1098 
    pass
1099 
 
4600 varun.gupt 1100 
  def getEBSSettlementSummaries(self, ):
1101 
    pass
1102 
 
1103 
  def markEBSSettlementUploaded(self, settlementId):
1104 
    """
1105 
    Parameters:
1106 
     - settlementId
1107 
    """
1108 
    pass
1109 
 
1110 
  def getEBSSettlementDate(self, settlementId):
1111 
    """
1112 
    Parameters:
1113 
     - settlementId
1114 
    """
1115 
    pass
1116 
 
4715 varun.gupt 1117 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1118 
    """
1119 
    Parameters:
1120 
     - settlementDateFrom
1121 
     - settlementDateTo
1122 
     - isRefund
1123 
    """
1124 
    pass
4600 varun.gupt 1125 
 
4715 varun.gupt 1126 
  def getReshippedOrderIds(self, orderIds):
1127 
    """
1128 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1129 
 
1130 
    Parameters:
1131 
     - orderIds
1132 
    """
1133 
    pass
1134 
 
5481 phani.kuma 1135 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1136 
    """
1137 
    Parameters:
1138 
     - vendorId
5481 phani.kuma 1139 
     - onlyVendorNotPaid
1140 
     - billingDateFrom
1141 
     - billingDateTo
4875 varun.gupt 1142 
    """
1143 
    pass
4757 mandeep.dh 1144 
 
5031 varun.gupt 1145 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1146 
    """
1147 
    Parameters:
1148 
     - startDate
1149 
     - endDate
1150 
    """
1151 
    pass
4875 varun.gupt 1152 
 
5067 varun.gupt 1153 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1154 
    """
1155 
    Parameters:
1156 
     - status
1157 
     - startDatetime
1158 
     - endDatetime
1159 
    """
1160 
    pass
5031 varun.gupt 1161 
 
5348 anupam.sin 1162 
  def updateCODAgent(self, agent, orderId):
1163 
    """
1164 
    Updates the agent who handled the COD verification call
1165 
 
1166 
    Parameters:
1167 
     - agent
1168 
     - orderId
1169 
    """
1170 
    pass
1171 
 
5099 varun.gupt 1172 
  def updateOrderAsPaidToVendor(self, orderId):
1173 
    """
1174 
    Parameters:
1175 
     - orderId
1176 
    """
1177 
    pass
5067 varun.gupt 1178 
 
5386 phani.kuma 1179 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1180 
    """
1181 
    Parameters:
1182 
     - orderId
1183 
    """
1184 
    pass
1185 
 
5208 varun.gupt 1186 
  def getRefundedOrdersMarkedPaid(self, ):
1187 
    pass
5099 varun.gupt 1188 
 
5447 anupam.sin 1189 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1190 
    """
1191 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1192 
 
5447 anupam.sin 1193 
 
1194 
    Parameters:
1195 
     - minOrderId
1196 
     - maxOrderId
1197 
    """
1198 
    pass
1199 
 
5527 anupam.sin 1200 
  def getAllAttributesForOrderId(self, orderId):
1201 
    """
1202 
    gets all attributes for a given orderId
5447 anupam.sin 1203 
 
5527 anupam.sin 1204 
    Parameters:
1205 
     - orderId
1206 
    """
1207 
    pass
1208 
 
5676 rajveer 1209 
  def setOrderAttributes(self, orderId, attributes):
1210 
    """
1211 
    sets attributes for an order
1212 
 
1213 
    Parameters:
1214 
     - orderId
1215 
     - attributes
1216 
    """
1217 
    pass
1218 
 
5527 anupam.sin 1219 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1220 
    """
1221 
    sets attributes for all orders in a transaction
1222 
 
1223 
    Parameters:
1224 
     - transactionId
1225 
     - attribute
1226 
    """
1227 
    pass
1228 
 
5553 rajveer 1229 
  def getReceivePendingOrders(self, storeId):
1230 
    """
1231 
    Parameters:
1232 
     - storeId
1233 
    """
1234 
    pass
5527 anupam.sin 1235 
 
5553 rajveer 1236 
  def getReceivedAtStoreOrders(self, storeId):
1237 
    """
1238 
    Parameters:
1239 
     - storeId
1240 
    """
1241 
    pass
1242 
 
5713 rajveer 1243 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1244 
    """
1245 
    Parameters:
1246 
     - storeId
1247 
     - fromDate
1248 
     - toDate
1249 
     - onlyCod
1250 
    """
1251 
    pass
1252 
 
5833 rajveer 1253 
  def getOrderAttributeValue(self, orderId, attributeName):
1254 
    """
1255 
    Parameters:
1256 
     - orderId
1257 
     - attributeName
1258 
    """
1259 
    pass
1260 
 
5593 mandeep.dh 1261 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1262 
    """
1263 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1264 
    invoked while scanning IN of items.
5553 rajveer 1265 
 
5593 mandeep.dh 1266 
    Parameters:
1267 
     - itemId
1268 
     - quantity
1269 
     - fulfilmentWarehouseId
1270 
     - billingWarehouseId
1271 
    """
1272 
    pass
1273 
 
1274 
 
3376 rajveer 1275 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1276 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1277 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1278 
 
1279 
  def createTransaction(self, transaction):
1280 
    """
1281 
    Parameters:
1282 
     - transaction
1283 
    """
1284 
    self.send_createTransaction(transaction)
132 ashish 1285 
    return self.recv_createTransaction()
94 ashish 1286 
 
1287 
  def send_createTransaction(self, transaction):
1288 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1289 
    args = createTransaction_args()
1290 
    args.transaction = transaction
1291 
    args.write(self._oprot)
1292 
    self._oprot.writeMessageEnd()
1293 
    self._oprot.trans.flush()
1294 
 
1295 
  def recv_createTransaction(self, ):
1296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1297 
    if mtype == TMessageType.EXCEPTION:
1298 
      x = TApplicationException()
1299 
      x.read(self._iprot)
1300 
      self._iprot.readMessageEnd()
1301 
      raise x
1302 
    result = createTransaction_result()
1303 
    result.read(self._iprot)
1304 
    self._iprot.readMessageEnd()
3431 rajveer 1305 
    if result.success is not None:
132 ashish 1306 
      return result.success
3431 rajveer 1307 
    if result.ex is not None:
94 ashish 1308 
      raise result.ex
132 ashish 1309 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1310 
 
1311 
  def getTransaction(self, id):
1312 
    """
1313 
    Parameters:
1314 
     - id
1315 
    """
1316 
    self.send_getTransaction(id)
1317 
    return self.recv_getTransaction()
1318 
 
1319 
  def send_getTransaction(self, id):
1320 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1321 
    args = getTransaction_args()
1322 
    args.id = id
1323 
    args.write(self._oprot)
1324 
    self._oprot.writeMessageEnd()
1325 
    self._oprot.trans.flush()
1326 
 
1327 
  def recv_getTransaction(self, ):
1328 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1329 
    if mtype == TMessageType.EXCEPTION:
1330 
      x = TApplicationException()
1331 
      x.read(self._iprot)
1332 
      self._iprot.readMessageEnd()
1333 
      raise x
1334 
    result = getTransaction_result()
1335 
    result.read(self._iprot)
1336 
    self._iprot.readMessageEnd()
3431 rajveer 1337 
    if result.success is not None:
94 ashish 1338 
      return result.success
3431 rajveer 1339 
    if result.ex is not None:
94 ashish 1340 
      raise result.ex
1341 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1342 
 
1343 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1344 
    """
1345 
    Parameters:
1346 
     - customerId
1347 
     - from_date
1348 
     - to_date
1349 
     - status
1350 
    """
1351 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1352 
    return self.recv_getTransactionsForCustomer()
1353 
 
1354 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1355 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1356 
    args = getTransactionsForCustomer_args()
1357 
    args.customerId = customerId
1358 
    args.from_date = from_date
1359 
    args.to_date = to_date
1360 
    args.status = status
1361 
    args.write(self._oprot)
1362 
    self._oprot.writeMessageEnd()
1363 
    self._oprot.trans.flush()
1364 
 
1365 
  def recv_getTransactionsForCustomer(self, ):
1366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1367 
    if mtype == TMessageType.EXCEPTION:
1368 
      x = TApplicationException()
1369 
      x.read(self._iprot)
1370 
      self._iprot.readMessageEnd()
1371 
      raise x
1372 
    result = getTransactionsForCustomer_result()
1373 
    result.read(self._iprot)
1374 
    self._iprot.readMessageEnd()
3431 rajveer 1375 
    if result.success is not None:
94 ashish 1376 
      return result.success
3431 rajveer 1377 
    if result.ex is not None:
94 ashish 1378 
      raise result.ex
1379 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1380 
 
132 ashish 1381 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1382 
    """
1383 
    Parameters:
1384 
     - shoppingCartId
1385 
    """
1386 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1387 
    return self.recv_getTransactionsForShoppingCartId()
1388 
 
1389 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1390 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1391 
    args = getTransactionsForShoppingCartId_args()
1392 
    args.shoppingCartId = shoppingCartId
1393 
    args.write(self._oprot)
1394 
    self._oprot.writeMessageEnd()
1395 
    self._oprot.trans.flush()
1396 
 
1397 
  def recv_getTransactionsForShoppingCartId(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 = getTransactionsForShoppingCartId_result()
1405 
    result.read(self._iprot)
1406 
    self._iprot.readMessageEnd()
3431 rajveer 1407 
    if result.success is not None:
132 ashish 1408 
      return result.success
3431 rajveer 1409 
    if result.ex is not None:
132 ashish 1410 
      raise result.ex
1411 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1412 
 
94 ashish 1413 
  def getTransactionStatus(self, transactionId):
1414 
    """
1415 
    Parameters:
1416 
     - transactionId
1417 
    """
1418 
    self.send_getTransactionStatus(transactionId)
1419 
    return self.recv_getTransactionStatus()
1420 
 
1421 
  def send_getTransactionStatus(self, transactionId):
1422 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1423 
    args = getTransactionStatus_args()
1424 
    args.transactionId = transactionId
1425 
    args.write(self._oprot)
1426 
    self._oprot.writeMessageEnd()
1427 
    self._oprot.trans.flush()
1428 
 
1429 
  def recv_getTransactionStatus(self, ):
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
1436 
    result = getTransactionStatus_result()
1437 
    result.read(self._iprot)
1438 
    self._iprot.readMessageEnd()
3431 rajveer 1439 
    if result.success is not None:
94 ashish 1440 
      return result.success
3431 rajveer 1441 
    if result.ex is not None:
94 ashish 1442 
      raise result.ex
1443 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1444 
 
5527 anupam.sin 1445 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1446 
    """
1447 
    Parameters:
1448 
     - transactionId
1449 
     - status
1450 
     - description
5527 anupam.sin 1451 
     - pickUp
1452 
     - orderType
94 ashish 1453 
    """
5527 anupam.sin 1454 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1455 
    return self.recv_changeTransactionStatus()
1456 
 
5527 anupam.sin 1457 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1458 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1459 
    args = changeTransactionStatus_args()
1460 
    args.transactionId = transactionId
1461 
    args.status = status
1462 
    args.description = description
5527 anupam.sin 1463 
    args.pickUp = pickUp
1464 
    args.orderType = orderType
94 ashish 1465 
    args.write(self._oprot)
1466 
    self._oprot.writeMessageEnd()
1467 
    self._oprot.trans.flush()
1468 
 
1469 
  def recv_changeTransactionStatus(self, ):
1470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1471 
    if mtype == TMessageType.EXCEPTION:
1472 
      x = TApplicationException()
1473 
      x.read(self._iprot)
1474 
      self._iprot.readMessageEnd()
1475 
      raise x
1476 
    result = changeTransactionStatus_result()
1477 
    result.read(self._iprot)
1478 
    self._iprot.readMessageEnd()
3431 rajveer 1479 
    if result.success is not None:
94 ashish 1480 
      return result.success
3431 rajveer 1481 
    if result.ex is not None:
94 ashish 1482 
      raise result.ex
1483 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1484 
 
1398 varun.gupt 1485 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1486 
    """
1487 
    Parameters:
1488 
     - transactionId
1489 
    """
1398 varun.gupt 1490 
    self.send_enqueueTransactionInfoEmail(transactionId)
1491 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1492 
 
1398 varun.gupt 1493 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1494 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1495 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1496 
    args.transactionId = transactionId
1497 
    args.write(self._oprot)
1498 
    self._oprot.writeMessageEnd()
1499 
    self._oprot.trans.flush()
1500 
 
1398 varun.gupt 1501 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1503 
    if mtype == TMessageType.EXCEPTION:
1504 
      x = TApplicationException()
1505 
      x.read(self._iprot)
1506 
      self._iprot.readMessageEnd()
1507 
      raise x
1398 varun.gupt 1508 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1509 
    result.read(self._iprot)
1510 
    self._iprot.readMessageEnd()
3431 rajveer 1511 
    if result.success is not None:
1382 varun.gupt 1512 
      return result.success
3431 rajveer 1513 
    if result.ex is not None:
1382 varun.gupt 1514 
      raise result.ex
1398 varun.gupt 1515 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1516 
 
4801 anupam.sin 1517 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1518 
    """
1519 
    Parameters:
4801 anupam.sin 1520 
     - statuses
483 rajveer 1521 
     - from_date
1522 
     - to_date
1523 
     - warehouse_id
94 ashish 1524 
    """
4801 anupam.sin 1525 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1526 
    return self.recv_getAllOrders()
94 ashish 1527 
 
4801 anupam.sin 1528 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1529 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1530 
    args = getAllOrders_args()
4801 anupam.sin 1531 
    args.statuses = statuses
483 rajveer 1532 
    args.from_date = from_date
1533 
    args.to_date = to_date
1534 
    args.warehouse_id = warehouse_id
94 ashish 1535 
    args.write(self._oprot)
1536 
    self._oprot.writeMessageEnd()
1537 
    self._oprot.trans.flush()
1538 
 
483 rajveer 1539 
  def recv_getAllOrders(self, ):
94 ashish 1540 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1541 
    if mtype == TMessageType.EXCEPTION:
1542 
      x = TApplicationException()
1543 
      x.read(self._iprot)
1544 
      self._iprot.readMessageEnd()
1545 
      raise x
483 rajveer 1546 
    result = getAllOrders_result()
94 ashish 1547 
    result.read(self._iprot)
1548 
    self._iprot.readMessageEnd()
3431 rajveer 1549 
    if result.success is not None:
94 ashish 1550 
      return result.success
3431 rajveer 1551 
    if result.ex is not None:
94 ashish 1552 
      raise result.ex
483 rajveer 1553 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1554 
 
4133 chandransh 1555 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1556 
    """
1557 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1558 
    Pass the status as null and the limit as 0 to ignore them.
1559 
 
1560 
    Parameters:
1561 
     - statuses
1562 
     - offset
1563 
     - limit
1564 
     - warehouse_id
1565 
    """
1566 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1567 
    return self.recv_getOrdersInBatch()
1568 
 
1569 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1570 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1571 
    args = getOrdersInBatch_args()
1572 
    args.statuses = statuses
1573 
    args.offset = offset
1574 
    args.limit = limit
1575 
    args.warehouse_id = warehouse_id
1576 
    args.write(self._oprot)
1577 
    self._oprot.writeMessageEnd()
1578 
    self._oprot.trans.flush()
1579 
 
1580 
  def recv_getOrdersInBatch(self, ):
1581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1582 
    if mtype == TMessageType.EXCEPTION:
1583 
      x = TApplicationException()
1584 
      x.read(self._iprot)
1585 
      self._iprot.readMessageEnd()
1586 
      raise x
1587 
    result = getOrdersInBatch_result()
1588 
    result.read(self._iprot)
1589 
    self._iprot.readMessageEnd()
1590 
    if result.success is not None:
1591 
      return result.success
1592 
    if result.ex is not None:
1593 
      raise result.ex
1594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1595 
 
1596 
  def getOrderCount(self, statuses, warehouseId):
1597 
    """
1598 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1599 
 
1600 
    Parameters:
1601 
     - statuses
1602 
     - warehouseId
1603 
    """
1604 
    self.send_getOrderCount(statuses, warehouseId)
1605 
    return self.recv_getOrderCount()
1606 
 
1607 
  def send_getOrderCount(self, statuses, warehouseId):
1608 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1609 
    args = getOrderCount_args()
1610 
    args.statuses = statuses
1611 
    args.warehouseId = warehouseId
1612 
    args.write(self._oprot)
1613 
    self._oprot.writeMessageEnd()
1614 
    self._oprot.trans.flush()
1615 
 
1616 
  def recv_getOrderCount(self, ):
1617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1618 
    if mtype == TMessageType.EXCEPTION:
1619 
      x = TApplicationException()
1620 
      x.read(self._iprot)
1621 
      self._iprot.readMessageEnd()
1622 
      raise x
1623 
    result = getOrderCount_result()
1624 
    result.read(self._iprot)
1625 
    self._iprot.readMessageEnd()
1626 
    if result.success is not None:
1627 
      return result.success
1628 
    if result.ex is not None:
1629 
      raise result.ex
1630 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1631 
 
999 varun.gupt 1632 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1633 
    """
1132 chandransh 1634 
    Returns orders within a range of their billing dates
3431 rajveer 1635 
 
999 varun.gupt 1636 
    Parameters:
1637 
     - status
1638 
     - start_billing_date
1639 
     - end_billing_date
1640 
     - warehouse_id
1641 
    """
1642 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1643 
    return self.recv_getOrdersByBillingDate()
1644 
 
1645 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1646 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1647 
    args = getOrdersByBillingDate_args()
1648 
    args.status = status
1649 
    args.start_billing_date = start_billing_date
1650 
    args.end_billing_date = end_billing_date
1651 
    args.warehouse_id = warehouse_id
1652 
    args.write(self._oprot)
1653 
    self._oprot.writeMessageEnd()
1654 
    self._oprot.trans.flush()
1655 
 
1656 
  def recv_getOrdersByBillingDate(self, ):
1657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1658 
    if mtype == TMessageType.EXCEPTION:
1659 
      x = TApplicationException()
1660 
      x.read(self._iprot)
1661 
      self._iprot.readMessageEnd()
1662 
      raise x
1663 
    result = getOrdersByBillingDate_result()
1664 
    result.read(self._iprot)
1665 
    self._iprot.readMessageEnd()
3431 rajveer 1666 
    if result.success is not None:
999 varun.gupt 1667 
      return result.success
3431 rajveer 1668 
    if result.ex is not None:
999 varun.gupt 1669 
      raise result.ex
1670 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1671 
 
3451 chandransh 1672 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1673 
    """
1674 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1675 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1676 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1677 
 
3427 chandransh 1678 
    Parameters:
1679 
     - fromShippingDate
1680 
     - toShippingDate
1681 
     - providerId
1682 
     - warehouseId
3451 chandransh 1683 
     - cod
3427 chandransh 1684 
    """
3451 chandransh 1685 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1686 
    return self.recv_getOrdersByShippingDate()
1687 
 
3451 chandransh 1688 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1689 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1690 
    args = getOrdersByShippingDate_args()
1691 
    args.fromShippingDate = fromShippingDate
1692 
    args.toShippingDate = toShippingDate
1693 
    args.providerId = providerId
1694 
    args.warehouseId = warehouseId
3451 chandransh 1695 
    args.cod = cod
3427 chandransh 1696 
    args.write(self._oprot)
1697 
    self._oprot.writeMessageEnd()
1698 
    self._oprot.trans.flush()
1699 
 
1700 
  def recv_getOrdersByShippingDate(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 = getOrdersByShippingDate_result()
1708 
    result.read(self._iprot)
1709 
    self._iprot.readMessageEnd()
3431 rajveer 1710 
    if result.success is not None:
3427 chandransh 1711 
      return result.success
3431 rajveer 1712 
    if result.ex is not None:
3427 chandransh 1713 
      raise result.ex
1714 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1715 
 
1382 varun.gupt 1716 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1717 
    """
1718 
    Returns order ids for orders which can be returned
3431 rajveer 1719 
 
1382 varun.gupt 1720 
    Parameters:
1721 
     - customer_id
1722 
     - limit
1723 
    """
1724 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1725 
    return self.recv_getReturnableOrdersForCustomer()
1726 
 
1727 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1728 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1729 
    args = getReturnableOrdersForCustomer_args()
1730 
    args.customer_id = customer_id
1731 
    args.limit = limit
1732 
    args.write(self._oprot)
1733 
    self._oprot.writeMessageEnd()
1734 
    self._oprot.trans.flush()
1735 
 
1736 
  def recv_getReturnableOrdersForCustomer(self, ):
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
1743 
    result = getReturnableOrdersForCustomer_result()
1744 
    result.read(self._iprot)
1745 
    self._iprot.readMessageEnd()
3431 rajveer 1746 
    if result.success is not None:
1382 varun.gupt 1747 
      return result.success
3431 rajveer 1748 
    if result.ex is not None:
1382 varun.gupt 1749 
      raise result.ex
1750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1751 
 
1752 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1753 
    """
1754 
    Returns order ids for orders which can be cancelled
3431 rajveer 1755 
 
1382 varun.gupt 1756 
    Parameters:
1757 
     - customer_id
1758 
     - limit
1759 
    """
1760 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1761 
    return self.recv_getCancellableOrdersForCustomer()
1762 
 
1763 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1764 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1765 
    args = getCancellableOrdersForCustomer_args()
1766 
    args.customer_id = customer_id
1767 
    args.limit = limit
1768 
    args.write(self._oprot)
1769 
    self._oprot.writeMessageEnd()
1770 
    self._oprot.trans.flush()
1771 
 
1772 
  def recv_getCancellableOrdersForCustomer(self, ):
1773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1774 
    if mtype == TMessageType.EXCEPTION:
1775 
      x = TApplicationException()
1776 
      x.read(self._iprot)
1777 
      self._iprot.readMessageEnd()
1778 
      raise x
1779 
    result = getCancellableOrdersForCustomer_result()
1780 
    result.read(self._iprot)
1781 
    self._iprot.readMessageEnd()
3431 rajveer 1782 
    if result.success is not None:
1382 varun.gupt 1783 
      return result.success
3431 rajveer 1784 
    if result.ex is not None:
1382 varun.gupt 1785 
      raise result.ex
1786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1787 
 
483 rajveer 1788 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1789 
    """
1790 
    Parameters:
483 rajveer 1791 
     - orderId
1792 
     - status
1793 
     - description
94 ashish 1794 
    """
483 rajveer 1795 
    self.send_changeOrderStatus(orderId, status, description)
1796 
    return self.recv_changeOrderStatus()
94 ashish 1797 
 
483 rajveer 1798 
  def send_changeOrderStatus(self, orderId, status, description):
1799 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1800 
    args = changeOrderStatus_args()
1801 
    args.orderId = orderId
1802 
    args.status = status
1803 
    args.description = description
94 ashish 1804 
    args.write(self._oprot)
1805 
    self._oprot.writeMessageEnd()
1806 
    self._oprot.trans.flush()
1807 
 
483 rajveer 1808 
  def recv_changeOrderStatus(self, ):
94 ashish 1809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1810 
    if mtype == TMessageType.EXCEPTION:
1811 
      x = TApplicationException()
1812 
      x.read(self._iprot)
1813 
      self._iprot.readMessageEnd()
1814 
      raise x
483 rajveer 1815 
    result = changeOrderStatus_result()
94 ashish 1816 
    result.read(self._iprot)
1817 
    self._iprot.readMessageEnd()
3431 rajveer 1818 
    if result.success is not None:
94 ashish 1819 
      return result.success
3431 rajveer 1820 
    if result.ex is not None:
94 ashish 1821 
      raise result.ex
483 rajveer 1822 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1823 
 
1528 ankur.sing 1824 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1825 
    """
1528 ankur.sing 1826 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1827 
    only user who owns the transaction can view its order details.
3431 rajveer 1828 
 
94 ashish 1829 
    Parameters:
1830 
     - transactionId
1528 ankur.sing 1831 
     - customerId
94 ashish 1832 
    """
1528 ankur.sing 1833 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1834 
    return self.recv_getOrdersForTransaction()
94 ashish 1835 
 
1528 ankur.sing 1836 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1837 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1838 
    args = getOrdersForTransaction_args()
94 ashish 1839 
    args.transactionId = transactionId
1528 ankur.sing 1840 
    args.customerId = customerId
94 ashish 1841 
    args.write(self._oprot)
1842 
    self._oprot.writeMessageEnd()
1843 
    self._oprot.trans.flush()
1844 
 
483 rajveer 1845 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1847 
    if mtype == TMessageType.EXCEPTION:
1848 
      x = TApplicationException()
1849 
      x.read(self._iprot)
1850 
      self._iprot.readMessageEnd()
1851 
      raise x
483 rajveer 1852 
    result = getOrdersForTransaction_result()
94 ashish 1853 
    result.read(self._iprot)
1854 
    self._iprot.readMessageEnd()
3431 rajveer 1855 
    if result.success is not None:
94 ashish 1856 
      return result.success
3431 rajveer 1857 
    if result.ex is not None:
94 ashish 1858 
      raise result.ex
483 rajveer 1859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1860 
 
3014 chandransh 1861 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1862 
    """
3014 chandransh 1863 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1864 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1865 
 
94 ashish 1866 
    Parameters:
483 rajveer 1867 
     - customerId
1868 
     - from_date
1869 
     - to_date
3014 chandransh 1870 
     - statuses
94 ashish 1871 
    """
3014 chandransh 1872 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1873 
    return self.recv_getOrdersForCustomer()
94 ashish 1874 
 
3014 chandransh 1875 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1876 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1877 
    args = getOrdersForCustomer_args()
1878 
    args.customerId = customerId
1879 
    args.from_date = from_date
1880 
    args.to_date = to_date
3014 chandransh 1881 
    args.statuses = statuses
94 ashish 1882 
    args.write(self._oprot)
1883 
    self._oprot.writeMessageEnd()
1884 
    self._oprot.trans.flush()
1885 
 
483 rajveer 1886 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1888 
    if mtype == TMessageType.EXCEPTION:
1889 
      x = TApplicationException()
1890 
      x.read(self._iprot)
1891 
      self._iprot.readMessageEnd()
1892 
      raise x
483 rajveer 1893 
    result = getOrdersForCustomer_result()
94 ashish 1894 
    result.read(self._iprot)
1895 
    self._iprot.readMessageEnd()
3431 rajveer 1896 
    if result.success is not None:
94 ashish 1897 
      return result.success
3431 rajveer 1898 
    if result.ex is not None:
94 ashish 1899 
      raise result.ex
483 rajveer 1900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1901 
 
483 rajveer 1902 
  def createOrder(self, order):
94 ashish 1903 
    """
1904 
    Parameters:
483 rajveer 1905 
     - order
94 ashish 1906 
    """
483 rajveer 1907 
    self.send_createOrder(order)
1908 
    return self.recv_createOrder()
94 ashish 1909 
 
483 rajveer 1910 
  def send_createOrder(self, order):
1911 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1912 
    args = createOrder_args()
1913 
    args.order = order
94 ashish 1914 
    args.write(self._oprot)
1915 
    self._oprot.writeMessageEnd()
1916 
    self._oprot.trans.flush()
1917 
 
483 rajveer 1918 
  def recv_createOrder(self, ):
94 ashish 1919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1920 
    if mtype == TMessageType.EXCEPTION:
1921 
      x = TApplicationException()
1922 
      x.read(self._iprot)
1923 
      self._iprot.readMessageEnd()
1924 
      raise x
483 rajveer 1925 
    result = createOrder_result()
94 ashish 1926 
    result.read(self._iprot)
1927 
    self._iprot.readMessageEnd()
3431 rajveer 1928 
    if result.success is not None:
94 ashish 1929 
      return result.success
3431 rajveer 1930 
    if result.ex is not None:
94 ashish 1931 
      raise result.ex
483 rajveer 1932 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1933 
 
483 rajveer 1934 
  def getOrder(self, id):
94 ashish 1935 
    """
1936 
    Parameters:
483 rajveer 1937 
     - id
94 ashish 1938 
    """
483 rajveer 1939 
    self.send_getOrder(id)
1940 
    return self.recv_getOrder()
94 ashish 1941 
 
483 rajveer 1942 
  def send_getOrder(self, id):
1943 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1944 
    args = getOrder_args()
1945 
    args.id = id
94 ashish 1946 
    args.write(self._oprot)
1947 
    self._oprot.writeMessageEnd()
1948 
    self._oprot.trans.flush()
1949 
 
483 rajveer 1950 
  def recv_getOrder(self, ):
94 ashish 1951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1952 
    if mtype == TMessageType.EXCEPTION:
1953 
      x = TApplicationException()
1954 
      x.read(self._iprot)
1955 
      self._iprot.readMessageEnd()
1956 
      raise x
483 rajveer 1957 
    result = getOrder_result()
94 ashish 1958 
    result.read(self._iprot)
1959 
    self._iprot.readMessageEnd()
3431 rajveer 1960 
    if result.success is not None:
94 ashish 1961 
      return result.success
3431 rajveer 1962 
    if result.ex is not None:
94 ashish 1963 
      raise result.ex
483 rajveer 1964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1965 
 
483 rajveer 1966 
  def getLineItemsForOrder(self, orderId):
94 ashish 1967 
    """
1968 
    Parameters:
483 rajveer 1969 
     - orderId
94 ashish 1970 
    """
483 rajveer 1971 
    self.send_getLineItemsForOrder(orderId)
1972 
    return self.recv_getLineItemsForOrder()
94 ashish 1973 
 
483 rajveer 1974 
  def send_getLineItemsForOrder(self, orderId):
1975 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1976 
    args = getLineItemsForOrder_args()
1977 
    args.orderId = orderId
94 ashish 1978 
    args.write(self._oprot)
1979 
    self._oprot.writeMessageEnd()
1980 
    self._oprot.trans.flush()
1981 
 
483 rajveer 1982 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1984 
    if mtype == TMessageType.EXCEPTION:
1985 
      x = TApplicationException()
1986 
      x.read(self._iprot)
1987 
      self._iprot.readMessageEnd()
1988 
      raise x
483 rajveer 1989 
    result = getLineItemsForOrder_result()
94 ashish 1990 
    result.read(self._iprot)
1991 
    self._iprot.readMessageEnd()
3431 rajveer 1992 
    if result.success is not None:
94 ashish 1993 
      return result.success
3431 rajveer 1994 
    if result.ex is not None:
94 ashish 1995 
      raise result.ex
483 rajveer 1996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1997 
 
4999 phani.kuma 1998 
  def getOrderList(self, order_ids):
1999 
    """
2000 
    Parameters:
2001 
     - order_ids
2002 
    """
2003 
    self.send_getOrderList(order_ids)
2004 
    return self.recv_getOrderList()
2005 
 
2006 
  def send_getOrderList(self, order_ids):
2007 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2008 
    args = getOrderList_args()
2009 
    args.order_ids = order_ids
2010 
    args.write(self._oprot)
2011 
    self._oprot.writeMessageEnd()
2012 
    self._oprot.trans.flush()
2013 
 
2014 
  def recv_getOrderList(self, ):
2015 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2016 
    if mtype == TMessageType.EXCEPTION:
2017 
      x = TApplicationException()
2018 
      x.read(self._iprot)
2019 
      self._iprot.readMessageEnd()
2020 
      raise x
2021 
    result = getOrderList_result()
2022 
    result.read(self._iprot)
2023 
    self._iprot.readMessageEnd()
2024 
    if result.success is not None:
2025 
      return result.success
2026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2027 
 
5386 phani.kuma 2028 
  def getOrderListForVendor(self, order_ids, vendorId):
2029 
    """
2030 
    Parameters:
2031 
     - order_ids
2032 
     - vendorId
2033 
    """
2034 
    self.send_getOrderListForVendor(order_ids, vendorId)
2035 
    return self.recv_getOrderListForVendor()
2036 
 
2037 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2038 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2039 
    args = getOrderListForVendor_args()
2040 
    args.order_ids = order_ids
2041 
    args.vendorId = vendorId
2042 
    args.write(self._oprot)
2043 
    self._oprot.writeMessageEnd()
2044 
    self._oprot.trans.flush()
2045 
 
2046 
  def recv_getOrderListForVendor(self, ):
2047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2048 
    if mtype == TMessageType.EXCEPTION:
2049 
      x = TApplicationException()
2050 
      x.read(self._iprot)
2051 
      self._iprot.readMessageEnd()
2052 
      raise x
2053 
    result = getOrderListForVendor_result()
2054 
    result.read(self._iprot)
2055 
    self._iprot.readMessageEnd()
2056 
    if result.success is not None:
2057 
      return result.success
2058 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2059 
 
1528 ankur.sing 2060 
  def getOrderForCustomer(self, orderId, customerId):
2061 
    """
2062 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2063 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2064 
 
1528 ankur.sing 2065 
    Parameters:
2066 
     - orderId
2067 
     - customerId
2068 
    """
2069 
    self.send_getOrderForCustomer(orderId, customerId)
2070 
    return self.recv_getOrderForCustomer()
2071 
 
2072 
  def send_getOrderForCustomer(self, orderId, customerId):
2073 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2074 
    args = getOrderForCustomer_args()
2075 
    args.orderId = orderId
2076 
    args.customerId = customerId
2077 
    args.write(self._oprot)
2078 
    self._oprot.writeMessageEnd()
2079 
    self._oprot.trans.flush()
2080 
 
2081 
  def recv_getOrderForCustomer(self, ):
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
2088 
    result = getOrderForCustomer_result()
2089 
    result.read(self._iprot)
2090 
    self._iprot.readMessageEnd()
3431 rajveer 2091 
    if result.success is not None:
1528 ankur.sing 2092 
      return result.success
3431 rajveer 2093 
    if result.ex is not None:
1528 ankur.sing 2094 
      raise result.ex
2095 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2096 
 
4444 rajveer 2097 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2098 
    """
2099 
    Parameters:
4394 rajveer 2100 
     - type
4444 rajveer 2101 
     - warehouseId
4394 rajveer 2102 
     - status
2103 
     - timestamp
3064 chandransh 2104 
    """
4444 rajveer 2105 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2106 
    return self.recv_getAlerts()
2107 
 
4444 rajveer 2108 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2109 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2110 
    args = getAlerts_args()
4394 rajveer 2111 
    args.type = type
4444 rajveer 2112 
    args.warehouseId = warehouseId
4394 rajveer 2113 
    args.status = status
2114 
    args.timestamp = timestamp
3064 chandransh 2115 
    args.write(self._oprot)
2116 
    self._oprot.writeMessageEnd()
2117 
    self._oprot.trans.flush()
2118 
 
2119 
  def recv_getAlerts(self, ):
2120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2121 
    if mtype == TMessageType.EXCEPTION:
2122 
      x = TApplicationException()
2123 
      x.read(self._iprot)
2124 
      self._iprot.readMessageEnd()
2125 
      raise x
2126 
    result = getAlerts_result()
2127 
    result.read(self._iprot)
2128 
    self._iprot.readMessageEnd()
3431 rajveer 2129 
    if result.success is not None:
3064 chandransh 2130 
      return result.success
2131 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2132 
 
4444 rajveer 2133 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2134 
    """
2135 
    Parameters:
2136 
     - type
4444 rajveer 2137 
     - warehouseId
4394 rajveer 2138 
     - description
3064 chandransh 2139 
    """
4444 rajveer 2140 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2141 
    self.recv_addAlert()
3064 chandransh 2142 
 
4444 rajveer 2143 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2144 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2145 
    args = addAlert_args()
3064 chandransh 2146 
    args.type = type
4444 rajveer 2147 
    args.warehouseId = warehouseId
4394 rajveer 2148 
    args.description = description
3064 chandransh 2149 
    args.write(self._oprot)
2150 
    self._oprot.writeMessageEnd()
2151 
    self._oprot.trans.flush()
2152 
 
4394 rajveer 2153 
  def recv_addAlert(self, ):
3064 chandransh 2154 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2155 
    if mtype == TMessageType.EXCEPTION:
2156 
      x = TApplicationException()
2157 
      x.read(self._iprot)
2158 
      self._iprot.readMessageEnd()
2159 
      raise x
4394 rajveer 2160 
    result = addAlert_result()
3064 chandransh 2161 
    result.read(self._iprot)
2162 
    self._iprot.readMessageEnd()
2163 
    return
2164 
 
4444 rajveer 2165 
  def markAlertsAsSeen(self, warehouseId):
2166 
    """
2167 
    Parameters:
2168 
     - warehouseId
2169 
    """
2170 
    self.send_markAlertsAsSeen(warehouseId)
2171 
    self.recv_markAlertsAsSeen()
2172 
 
2173 
  def send_markAlertsAsSeen(self, warehouseId):
2174 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2175 
    args = markAlertsAsSeen_args()
2176 
    args.warehouseId = warehouseId
2177 
    args.write(self._oprot)
2178 
    self._oprot.writeMessageEnd()
2179 
    self._oprot.trans.flush()
2180 
 
2181 
  def recv_markAlertsAsSeen(self, ):
2182 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2183 
    if mtype == TMessageType.EXCEPTION:
2184 
      x = TApplicationException()
2185 
      x.read(self._iprot)
2186 
      self._iprot.readMessageEnd()
2187 
      raise x
2188 
    result = markAlertsAsSeen_result()
2189 
    result.read(self._iprot)
2190 
    self._iprot.readMessageEnd()
2191 
    return
2192 
 
3064 chandransh 2193 
  def getValidOrderCount(self, ):
2194 
    """
2195 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2196 
    """
2197 
    self.send_getValidOrderCount()
2198 
    return self.recv_getValidOrderCount()
2199 
 
2200 
  def send_getValidOrderCount(self, ):
2201 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2202 
    args = getValidOrderCount_args()
2203 
    args.write(self._oprot)
2204 
    self._oprot.writeMessageEnd()
2205 
    self._oprot.trans.flush()
2206 
 
2207 
  def recv_getValidOrderCount(self, ):
2208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2209 
    if mtype == TMessageType.EXCEPTION:
2210 
      x = TApplicationException()
2211 
      x.read(self._iprot)
2212 
      self._iprot.readMessageEnd()
2213 
      raise x
2214 
    result = getValidOrderCount_result()
2215 
    result.read(self._iprot)
2216 
    self._iprot.readMessageEnd()
3431 rajveer 2217 
    if result.success is not None:
3064 chandransh 2218 
      return result.success
2219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2220 
 
2221 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2222 
    """
2223 
    Returns the number of distinct customers who have done successful transactions
2224 
    """
2225 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2226 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2227 
 
2228 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2229 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2230 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2231 
    args.write(self._oprot)
2232 
    self._oprot.writeMessageEnd()
2233 
    self._oprot.trans.flush()
2234 
 
2235 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2237 
    if mtype == TMessageType.EXCEPTION:
2238 
      x = TApplicationException()
2239 
      x.read(self._iprot)
2240 
      self._iprot.readMessageEnd()
2241 
      raise x
2242 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2243 
    result.read(self._iprot)
2244 
    self._iprot.readMessageEnd()
3431 rajveer 2245 
    if result.success is not None:
3064 chandransh 2246 
      return result.success
2247 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2248 
 
2249 
  def getValidOrdersAmountRange(self, ):
2250 
    """
2251 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2252 
    List contains two values, first minimum amount and second maximum amount.
2253 
    """
2254 
    self.send_getValidOrdersAmountRange()
2255 
    return self.recv_getValidOrdersAmountRange()
2256 
 
2257 
  def send_getValidOrdersAmountRange(self, ):
2258 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2259 
    args = getValidOrdersAmountRange_args()
2260 
    args.write(self._oprot)
2261 
    self._oprot.writeMessageEnd()
2262 
    self._oprot.trans.flush()
2263 
 
2264 
  def recv_getValidOrdersAmountRange(self, ):
2265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2266 
    if mtype == TMessageType.EXCEPTION:
2267 
      x = TApplicationException()
2268 
      x.read(self._iprot)
2269 
      self._iprot.readMessageEnd()
2270 
      raise x
2271 
    result = getValidOrdersAmountRange_result()
2272 
    result.read(self._iprot)
2273 
    self._iprot.readMessageEnd()
3431 rajveer 2274 
    if result.success is not None:
3064 chandransh 2275 
      return result.success
2276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2277 
 
2278 
  def getValidOrders(self, limit):
2279 
    """
2280 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2281 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2282 
 
3064 chandransh 2283 
    Parameters:
2284 
     - limit
2285 
    """
2286 
    self.send_getValidOrders(limit)
2287 
    return self.recv_getValidOrders()
2288 
 
2289 
  def send_getValidOrders(self, limit):
2290 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2291 
    args = getValidOrders_args()
2292 
    args.limit = limit
2293 
    args.write(self._oprot)
2294 
    self._oprot.writeMessageEnd()
2295 
    self._oprot.trans.flush()
2296 
 
2297 
  def recv_getValidOrders(self, ):
2298 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2299 
    if mtype == TMessageType.EXCEPTION:
2300 
      x = TApplicationException()
2301 
      x.read(self._iprot)
2302 
      self._iprot.readMessageEnd()
2303 
      raise x
2304 
    result = getValidOrders_result()
2305 
    result.read(self._iprot)
2306 
    self._iprot.readMessageEnd()
3431 rajveer 2307 
    if result.success is not None:
3064 chandransh 2308 
      return result.success
2309 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2310 
 
1220 chandransh 2311 
  def batchOrders(self, warehouseId):
2312 
    """
2313 
    Create a batch of all the pending orders for the given warehouse.
2314 
    The returned list is orderd by created_timestamp.
2315 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2316 
 
1220 chandransh 2317 
    Parameters:
2318 
     - warehouseId
2319 
    """
2320 
    self.send_batchOrders(warehouseId)
2321 
    return self.recv_batchOrders()
2322 
 
2323 
  def send_batchOrders(self, warehouseId):
2324 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2325 
    args = batchOrders_args()
2326 
    args.warehouseId = warehouseId
2327 
    args.write(self._oprot)
2328 
    self._oprot.writeMessageEnd()
2329 
    self._oprot.trans.flush()
2330 
 
2331 
  def recv_batchOrders(self, ):
2332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2333 
    if mtype == TMessageType.EXCEPTION:
2334 
      x = TApplicationException()
2335 
      x.read(self._iprot)
2336 
      self._iprot.readMessageEnd()
2337 
      raise x
2338 
    result = batchOrders_result()
2339 
    result.read(self._iprot)
2340 
    self._iprot.readMessageEnd()
3431 rajveer 2341 
    if result.success is not None:
1220 chandransh 2342 
      return result.success
3431 rajveer 2343 
    if result.ex is not None:
1220 chandransh 2344 
      raise result.ex
2345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2346 
 
1208 chandransh 2347 
  def markOrderAsOutOfStock(self, orderId):
2348 
    """
2349 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2350 
 
1208 chandransh 2351 
    Parameters:
2352 
     - orderId
2353 
    """
2354 
    self.send_markOrderAsOutOfStock(orderId)
2355 
    return self.recv_markOrderAsOutOfStock()
2356 
 
2357 
  def send_markOrderAsOutOfStock(self, orderId):
2358 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2359 
    args = markOrderAsOutOfStock_args()
2360 
    args.orderId = orderId
2361 
    args.write(self._oprot)
2362 
    self._oprot.writeMessageEnd()
2363 
    self._oprot.trans.flush()
2364 
 
2365 
  def recv_markOrderAsOutOfStock(self, ):
2366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2367 
    if mtype == TMessageType.EXCEPTION:
2368 
      x = TApplicationException()
2369 
      x.read(self._iprot)
2370 
      self._iprot.readMessageEnd()
2371 
      raise x
2372 
    result = markOrderAsOutOfStock_result()
2373 
    result.read(self._iprot)
2374 
    self._iprot.readMessageEnd()
3431 rajveer 2375 
    if result.success is not None:
1208 chandransh 2376 
      return result.success
3431 rajveer 2377 
    if result.ex is not None:
1208 chandransh 2378 
      raise result.ex
2379 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2380 
 
3064 chandransh 2381 
  def verifyOrder(self, orderId):
759 chandransh 2382 
    """
3064 chandransh 2383 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2384 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2385 
    used for all other orders as well.
2386 
    Throws an exception if no such order exists.
3431 rajveer 2387 
 
759 chandransh 2388 
    Parameters:
3064 chandransh 2389 
     - orderId
759 chandransh 2390 
    """
3064 chandransh 2391 
    self.send_verifyOrder(orderId)
2392 
    return self.recv_verifyOrder()
759 chandransh 2393 
 
3064 chandransh 2394 
  def send_verifyOrder(self, orderId):
2395 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2396 
    args = verifyOrder_args()
2397 
    args.orderId = orderId
759 chandransh 2398 
    args.write(self._oprot)
2399 
    self._oprot.writeMessageEnd()
2400 
    self._oprot.trans.flush()
2401 
 
3064 chandransh 2402 
  def recv_verifyOrder(self, ):
759 chandransh 2403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2404 
    if mtype == TMessageType.EXCEPTION:
2405 
      x = TApplicationException()
2406 
      x.read(self._iprot)
2407 
      self._iprot.readMessageEnd()
2408 
      raise x
3064 chandransh 2409 
    result = verifyOrder_result()
759 chandransh 2410 
    result.read(self._iprot)
2411 
    self._iprot.readMessageEnd()
3431 rajveer 2412 
    if result.success is not None:
759 chandransh 2413 
      return result.success
3431 rajveer 2414 
    if result.ex is not None:
759 chandransh 2415 
      raise result.ex
3064 chandransh 2416 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2417 
 
3064 chandransh 2418 
  def acceptOrder(self, orderId):
1113 chandransh 2419 
    """
3064 chandransh 2420 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2421 
    given order is not a COD order, it also captures the payment if the same has
2422 
    not been captured.
2423 
    Throws an exception if no such order exists.
3431 rajveer 2424 
 
1113 chandransh 2425 
    Parameters:
3064 chandransh 2426 
     - orderId
1113 chandransh 2427 
    """
3064 chandransh 2428 
    self.send_acceptOrder(orderId)
2429 
    return self.recv_acceptOrder()
1113 chandransh 2430 
 
3064 chandransh 2431 
  def send_acceptOrder(self, orderId):
2432 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2433 
    args = acceptOrder_args()
2434 
    args.orderId = orderId
1113 chandransh 2435 
    args.write(self._oprot)
2436 
    self._oprot.writeMessageEnd()
2437 
    self._oprot.trans.flush()
2438 
 
3064 chandransh 2439 
  def recv_acceptOrder(self, ):
1113 chandransh 2440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2441 
    if mtype == TMessageType.EXCEPTION:
2442 
      x = TApplicationException()
2443 
      x.read(self._iprot)
2444 
      self._iprot.readMessageEnd()
2445 
      raise x
3064 chandransh 2446 
    result = acceptOrder_result()
1113 chandransh 2447 
    result.read(self._iprot)
2448 
    self._iprot.readMessageEnd()
3431 rajveer 2449 
    if result.success is not None:
1113 chandransh 2450 
      return result.success
3431 rajveer 2451 
    if result.ex is not None:
1113 chandransh 2452 
      raise result.ex
3064 chandransh 2453 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2454 
 
5110 mandeep.dh 2455 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2456 
    """
3064 chandransh 2457 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2458 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2459 
    the IMEI no. if a -1 is supplied.
2460 
    Also, it generates an invoice number for the order, marks the order as
2461 
    BILLED and sets the billing timestamp.
2462 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2463 
 
1135 chandransh 2464 
    Parameters:
3064 chandransh 2465 
     - orderId
2466 
     - invoice_number
4658 mandeep.dh 2467 
     - serialNumber
4283 anupam.sin 2468 
     - itemNumber
3064 chandransh 2469 
     - billed_by
4264 rajveer 2470 
     - jacketNumber
4283 anupam.sin 2471 
     - billingType
5110 mandeep.dh 2472 
     - fulfilmentWarehouseId
4763 rajveer 2473 
     - authorize
1135 chandransh 2474 
    """
5110 mandeep.dh 2475 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2476 
    return self.recv_addBillingDetails()
1135 chandransh 2477 
 
5110 mandeep.dh 2478 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2479 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2480 
    args = addBillingDetails_args()
2481 
    args.orderId = orderId
2482 
    args.invoice_number = invoice_number
4658 mandeep.dh 2483 
    args.serialNumber = serialNumber
4283 anupam.sin 2484 
    args.itemNumber = itemNumber
3064 chandransh 2485 
    args.billed_by = billed_by
4264 rajveer 2486 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2487 
    args.billingType = billingType
5110 mandeep.dh 2488 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2489 
    args.authorize = authorize
1135 chandransh 2490 
    args.write(self._oprot)
2491 
    self._oprot.writeMessageEnd()
2492 
    self._oprot.trans.flush()
2493 
 
3064 chandransh 2494 
  def recv_addBillingDetails(self, ):
1135 chandransh 2495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2496 
    if mtype == TMessageType.EXCEPTION:
2497 
      x = TApplicationException()
2498 
      x.read(self._iprot)
2499 
      self._iprot.readMessageEnd()
2500 
      raise x
3064 chandransh 2501 
    result = addBillingDetails_result()
1135 chandransh 2502 
    result.read(self._iprot)
2503 
    self._iprot.readMessageEnd()
3431 rajveer 2504 
    if result.success is not None:
3064 chandransh 2505 
      return result.success
3431 rajveer 2506 
    if result.ex is not None:
1135 chandransh 2507 
      raise result.ex
3064 chandransh 2508 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2509 
 
4763 rajveer 2510 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2511 
    """
2512 
    Add the invoice number to the order.
2513 
 
2514 
    Parameters:
2515 
     - orderId
2516 
     - invoiceNumber
4763 rajveer 2517 
     - color
4579 rajveer 2518 
    """
4763 rajveer 2519 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2520 
    self.recv_addInvoiceNumber()
2521 
 
4763 rajveer 2522 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2523 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2524 
    args = addInvoiceNumber_args()
2525 
    args.orderId = orderId
2526 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2527 
    args.color = color
4579 rajveer 2528 
    args.write(self._oprot)
2529 
    self._oprot.writeMessageEnd()
2530 
    self._oprot.trans.flush()
2531 
 
2532 
  def recv_addInvoiceNumber(self, ):
2533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2534 
    if mtype == TMessageType.EXCEPTION:
2535 
      x = TApplicationException()
2536 
      x.read(self._iprot)
2537 
      self._iprot.readMessageEnd()
2538 
      raise x
2539 
    result = addInvoiceNumber_result()
2540 
    result.read(self._iprot)
2541 
    self._iprot.readMessageEnd()
2542 
    if result.ex is not None:
2543 
      raise result.ex
2544 
    return
2545 
 
4910 phani.kuma 2546 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2547 
    """
3064 chandransh 2548 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2549 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2550 
 
1408 ankur.sing 2551 
    Parameters:
3064 chandransh 2552 
     - warehouseId
1408 ankur.sing 2553 
     - providerId
3064 chandransh 2554 
     - cod
4910 phani.kuma 2555 
     - orderIds
1408 ankur.sing 2556 
    """
4910 phani.kuma 2557 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2558 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2559 
 
4910 phani.kuma 2560 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2561 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2562 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2563 
    args.warehouseId = warehouseId
1408 ankur.sing 2564 
    args.providerId = providerId
3064 chandransh 2565 
    args.cod = cod
4910 phani.kuma 2566 
    args.orderIds = orderIds
1408 ankur.sing 2567 
    args.write(self._oprot)
2568 
    self._oprot.writeMessageEnd()
2569 
    self._oprot.trans.flush()
2570 
 
4910 phani.kuma 2571 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2573 
    if mtype == TMessageType.EXCEPTION:
2574 
      x = TApplicationException()
2575 
      x.read(self._iprot)
2576 
      self._iprot.readMessageEnd()
2577 
      raise x
4910 phani.kuma 2578 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2579 
    result.read(self._iprot)
2580 
    self._iprot.readMessageEnd()
3431 rajveer 2581 
    if result.success is not None:
1408 ankur.sing 2582 
      return result.success
3431 rajveer 2583 
    if result.ex is not None:
3064 chandransh 2584 
      raise result.ex
4910 phani.kuma 2585 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2586 
 
5713 rajveer 2587 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2588 
    """
2589 
    Parameters:
2590 
     - providerId
2591 
     - orderIds
5713 rajveer 2592 
     - awbs
5676 rajveer 2593 
    """
5713 rajveer 2594 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2595 
    return self.recv_markOrdersAsReturnedFromStore()
2596 
 
5713 rajveer 2597 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2598 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2599 
    args = markOrdersAsReturnedFromStore_args()
2600 
    args.providerId = providerId
2601 
    args.orderIds = orderIds
5713 rajveer 2602 
    args.awbs = awbs
5676 rajveer 2603 
    args.write(self._oprot)
2604 
    self._oprot.writeMessageEnd()
2605 
    self._oprot.trans.flush()
2606 
 
2607 
  def recv_markOrdersAsReturnedFromStore(self, ):
2608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2609 
    if mtype == TMessageType.EXCEPTION:
2610 
      x = TApplicationException()
2611 
      x.read(self._iprot)
2612 
      self._iprot.readMessageEnd()
2613 
      raise x
2614 
    result = markOrdersAsReturnedFromStore_result()
2615 
    result.read(self._iprot)
2616 
    self._iprot.readMessageEnd()
2617 
    if result.success is not None:
2618 
      return result.success
2619 
    if result.ex is not None:
2620 
      raise result.ex
2621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2622 
 
4910 phani.kuma 2623 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2624 
    """
4910 phani.kuma 2625 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2626 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2627 
 
2628 
    Parameters:
2629 
     - providerId
4910 phani.kuma 2630 
     - pickupDetails
4410 rajveer 2631 
    """
4910 phani.kuma 2632 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2633 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2634 
 
4910 phani.kuma 2635 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2636 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2637 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2638 
    args.providerId = providerId
4910 phani.kuma 2639 
    args.pickupDetails = pickupDetails
4410 rajveer 2640 
    args.write(self._oprot)
2641 
    self._oprot.writeMessageEnd()
2642 
    self._oprot.trans.flush()
2643 
 
4910 phani.kuma 2644 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2646 
    if mtype == TMessageType.EXCEPTION:
2647 
      x = TApplicationException()
2648 
      x.read(self._iprot)
2649 
      self._iprot.readMessageEnd()
2650 
      raise x
4910 phani.kuma 2651 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2652 
    result.read(self._iprot)
2653 
    self._iprot.readMessageEnd()
2654 
    if result.ex is not None:
2655 
      raise result.ex
4910 phani.kuma 2656 
    return
4410 rajveer 2657 
 
4910 phani.kuma 2658 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2659 
    """
3064 chandransh 2660 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2661 
 
94 ashish 2662 
    Parameters:
3064 chandransh 2663 
     - providerId
304 ashish 2664 
    """
4910 phani.kuma 2665 
    self.send_getOrdersNotPickedUp(providerId)
2666 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2667 
 
4910 phani.kuma 2668 
  def send_getOrdersNotPickedUp(self, providerId):
2669 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2670 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2671 
    args.providerId = providerId
304 ashish 2672 
    args.write(self._oprot)
2673 
    self._oprot.writeMessageEnd()
2674 
    self._oprot.trans.flush()
2675 
 
4910 phani.kuma 2676 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2677 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2678 
    if mtype == TMessageType.EXCEPTION:
2679 
      x = TApplicationException()
2680 
      x.read(self._iprot)
2681 
      self._iprot.readMessageEnd()
2682 
      raise x
4910 phani.kuma 2683 
    result = getOrdersNotPickedUp_result()
304 ashish 2684 
    result.read(self._iprot)
2685 
    self._iprot.readMessageEnd()
3431 rajveer 2686 
    if result.success is not None:
304 ashish 2687 
      return result.success
4910 phani.kuma 2688 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2689 
 
3064 chandransh 2690 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2691 
    """
3064 chandransh 2692 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2693 
    the name of the receiver.
2694 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2695 
 
304 ashish 2696 
    Parameters:
3064 chandransh 2697 
     - providerId
2698 
     - deliveredOrders
304 ashish 2699 
    """
3064 chandransh 2700 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2701 
    self.recv_markOrdersAsDelivered()
304 ashish 2702 
 
3064 chandransh 2703 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2704 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2705 
    args = markOrdersAsDelivered_args()
2706 
    args.providerId = providerId
2707 
    args.deliveredOrders = deliveredOrders
304 ashish 2708 
    args.write(self._oprot)
2709 
    self._oprot.writeMessageEnd()
2710 
    self._oprot.trans.flush()
2711 
 
3064 chandransh 2712 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2714 
    if mtype == TMessageType.EXCEPTION:
2715 
      x = TApplicationException()
2716 
      x.read(self._iprot)
2717 
      self._iprot.readMessageEnd()
2718 
      raise x
3064 chandransh 2719 
    result = markOrdersAsDelivered_result()
304 ashish 2720 
    result.read(self._iprot)
2721 
    self._iprot.readMessageEnd()
3431 rajveer 2722 
    if result.ex is not None:
3064 chandransh 2723 
      raise result.ex
304 ashish 2724 
    return
2725 
 
4910 phani.kuma 2726 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2727 
    """
4910 phani.kuma 2728 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2729 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2730 
 
3064 chandransh 2731 
    Parameters:
2732 
     - providerId
2733 
     - returnedOrders
1596 ankur.sing 2734 
    """
4910 phani.kuma 2735 
    self.send_markAsRTOrders(providerId, returnedOrders)
2736 
    self.recv_markAsRTOrders()
304 ashish 2737 
 
4910 phani.kuma 2738 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2739 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2740 
    args = markAsRTOrders_args()
3064 chandransh 2741 
    args.providerId = providerId
2742 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2743 
    args.write(self._oprot)
2744 
    self._oprot.writeMessageEnd()
2745 
    self._oprot.trans.flush()
2746 
 
4910 phani.kuma 2747 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2749 
    if mtype == TMessageType.EXCEPTION:
2750 
      x = TApplicationException()
2751 
      x.read(self._iprot)
2752 
      self._iprot.readMessageEnd()
2753 
      raise x
4910 phani.kuma 2754 
    result = markAsRTOrders_result()
1596 ankur.sing 2755 
    result.read(self._iprot)
2756 
    self._iprot.readMessageEnd()
3431 rajveer 2757 
    if result.ex is not None:
3064 chandransh 2758 
      raise result.ex
2759 
    return
1596 ankur.sing 2760 
 
4910 phani.kuma 2761 
  def getRTOrders(self, providerId):
2762 
    """
2763 
    Returns a list of orders that were returned by courier.
2764 
 
2765 
    Parameters:
2766 
     - providerId
2767 
    """
2768 
    self.send_getRTOrders(providerId)
2769 
    return self.recv_getRTOrders()
2770 
 
2771 
  def send_getRTOrders(self, providerId):
2772 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2773 
    args = getRTOrders_args()
2774 
    args.providerId = providerId
2775 
    args.write(self._oprot)
2776 
    self._oprot.writeMessageEnd()
2777 
    self._oprot.trans.flush()
2778 
 
2779 
  def recv_getRTOrders(self, ):
2780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2781 
    if mtype == TMessageType.EXCEPTION:
2782 
      x = TApplicationException()
2783 
      x.read(self._iprot)
2784 
      self._iprot.readMessageEnd()
2785 
      raise x
2786 
    result = getRTOrders_result()
2787 
    result.read(self._iprot)
2788 
    self._iprot.readMessageEnd()
2789 
    if result.success is not None:
2790 
      return result.success
2791 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2792 
 
3064 chandransh 2793 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2794 
    """
3064 chandransh 2795 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2796 
 
3064 chandransh 2797 
    Parameters:
2798 
     - providerId
2799 
     - undeliveredOrders
1627 ankur.sing 2800 
    """
3064 chandransh 2801 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2802 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2803 
 
3064 chandransh 2804 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2805 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2806 
    args = updateNonDeliveryReason_args()
2807 
    args.providerId = providerId
2808 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2809 
    args.write(self._oprot)
2810 
    self._oprot.writeMessageEnd()
2811 
    self._oprot.trans.flush()
2812 
 
3064 chandransh 2813 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2815 
    if mtype == TMessageType.EXCEPTION:
2816 
      x = TApplicationException()
2817 
      x.read(self._iprot)
2818 
      self._iprot.readMessageEnd()
2819 
      raise x
3064 chandransh 2820 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2821 
    result.read(self._iprot)
2822 
    self._iprot.readMessageEnd()
4910 phani.kuma 2823 
    if result.ex is not None:
2824 
      raise result.ex
2825 
    return
2826 
 
2827 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2828 
    """
2829 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2830 
 
2831 
    Parameters:
2832 
     - providerId
2833 
    """
2834 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2835 
    return self.recv_getNonDeliveredOrdersbyCourier()
2836 
 
2837 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2838 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2839 
    args = getNonDeliveredOrdersbyCourier_args()
2840 
    args.providerId = providerId
2841 
    args.write(self._oprot)
2842 
    self._oprot.writeMessageEnd()
2843 
    self._oprot.trans.flush()
2844 
 
2845 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2847 
    if mtype == TMessageType.EXCEPTION:
2848 
      x = TApplicationException()
2849 
      x.read(self._iprot)
2850 
      self._iprot.readMessageEnd()
2851 
      raise x
2852 
    result = getNonDeliveredOrdersbyCourier_result()
2853 
    result.read(self._iprot)
2854 
    self._iprot.readMessageEnd()
4581 phani.kuma 2855 
    if result.success is not None:
2856 
      return result.success
4910 phani.kuma 2857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2858 
 
2859 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2860 
    """
2861 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2862 
 
2863 
    Parameters:
2864 
     - providerId
2865 
     - local_connected_orders
2866 
    """
2867 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2868 
    self.recv_markOrdersAsLocalConnected()
2869 
 
2870 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2871 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2872 
    args = markOrdersAsLocalConnected_args()
2873 
    args.providerId = providerId
2874 
    args.local_connected_orders = local_connected_orders
2875 
    args.write(self._oprot)
2876 
    self._oprot.writeMessageEnd()
2877 
    self._oprot.trans.flush()
2878 
 
2879 
  def recv_markOrdersAsLocalConnected(self, ):
2880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2881 
    if mtype == TMessageType.EXCEPTION:
2882 
      x = TApplicationException()
2883 
      x.read(self._iprot)
2884 
      self._iprot.readMessageEnd()
2885 
      raise x
2886 
    result = markOrdersAsLocalConnected_result()
2887 
    result.read(self._iprot)
2888 
    self._iprot.readMessageEnd()
3431 rajveer 2889 
    if result.ex is not None:
3064 chandransh 2890 
      raise result.ex
4910 phani.kuma 2891 
    return
1627 ankur.sing 2892 
 
4910 phani.kuma 2893 
  def getOrdersNotLocalConnected(self, providerId):
2894 
    """
2895 
    Returns a list of orders that were picked up or shipped but pending local connection.
2896 
 
2897 
    Parameters:
2898 
     - providerId
2899 
    """
2900 
    self.send_getOrdersNotLocalConnected(providerId)
2901 
    return self.recv_getOrdersNotLocalConnected()
2902 
 
2903 
  def send_getOrdersNotLocalConnected(self, providerId):
2904 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2905 
    args = getOrdersNotLocalConnected_args()
2906 
    args.providerId = providerId
2907 
    args.write(self._oprot)
2908 
    self._oprot.writeMessageEnd()
2909 
    self._oprot.trans.flush()
2910 
 
2911 
  def recv_getOrdersNotLocalConnected(self, ):
2912 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2913 
    if mtype == TMessageType.EXCEPTION:
2914 
      x = TApplicationException()
2915 
      x.read(self._iprot)
2916 
      self._iprot.readMessageEnd()
2917 
      raise x
2918 
    result = getOrdersNotLocalConnected_result()
2919 
    result.read(self._iprot)
2920 
    self._iprot.readMessageEnd()
2921 
    if result.success is not None:
2922 
      return result.success
2923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2924 
 
2925 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2926 
    """
2927 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2928 
 
2929 
    Parameters:
2930 
     - providerId
2931 
     - destination_city_reached_orders
2932 
    """
2933 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2934 
    self.recv_markOrdersAsDestinationCityReached()
2935 
 
2936 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2937 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2938 
    args = markOrdersAsDestinationCityReached_args()
2939 
    args.providerId = providerId
2940 
    args.destination_city_reached_orders = destination_city_reached_orders
2941 
    args.write(self._oprot)
2942 
    self._oprot.writeMessageEnd()
2943 
    self._oprot.trans.flush()
2944 
 
2945 
  def recv_markOrdersAsDestinationCityReached(self, ):
2946 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2947 
    if mtype == TMessageType.EXCEPTION:
2948 
      x = TApplicationException()
2949 
      x.read(self._iprot)
2950 
      self._iprot.readMessageEnd()
2951 
      raise x
2952 
    result = markOrdersAsDestinationCityReached_result()
2953 
    result.read(self._iprot)
2954 
    self._iprot.readMessageEnd()
2955 
    if result.ex is not None:
2956 
      raise result.ex
2957 
    return
2958 
 
2959 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2960 
    """
2961 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2962 
 
2963 
    Parameters:
2964 
     - providerId
2965 
     - first_atdl_orders
2966 
    """
2967 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2968 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2969 
 
2970 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2971 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2972 
    args = markOrdersAsFirstDeliveryAttempted_args()
2973 
    args.providerId = providerId
2974 
    args.first_atdl_orders = first_atdl_orders
2975 
    args.write(self._oprot)
2976 
    self._oprot.writeMessageEnd()
2977 
    self._oprot.trans.flush()
2978 
 
2979 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2981 
    if mtype == TMessageType.EXCEPTION:
2982 
      x = TApplicationException()
2983 
      x.read(self._iprot)
2984 
      self._iprot.readMessageEnd()
2985 
      raise x
2986 
    result = markOrdersAsFirstDeliveryAttempted_result()
2987 
    result.read(self._iprot)
2988 
    self._iprot.readMessageEnd()
2989 
    if result.ex is not None:
2990 
      raise result.ex
2991 
    return
2992 
 
3064 chandransh 2993 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2994 
    """
3064 chandransh 2995 
    Returns the list of orders whose delivery time has passed but have not been
2996 
    delivered yet for the given provider and warehouse. To get a complete list of
2997 
    undelivered orders, pass them as -1.
2998 
    Returns an empty list if no such orders exist.
3431 rajveer 2999 
 
1886 ankur.sing 3000 
    Parameters:
3064 chandransh 3001 
     - providerId
3002 
     - warehouseId
1886 ankur.sing 3003 
    """
3064 chandransh 3004 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3005 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3006 
 
3064 chandransh 3007 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3008 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3009 
    args = getUndeliveredOrders_args()
3010 
    args.providerId = providerId
3011 
    args.warehouseId = warehouseId
1886 ankur.sing 3012 
    args.write(self._oprot)
3013 
    self._oprot.writeMessageEnd()
3014 
    self._oprot.trans.flush()
3015 
 
3064 chandransh 3016 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3018 
    if mtype == TMessageType.EXCEPTION:
3019 
      x = TApplicationException()
3020 
      x.read(self._iprot)
3021 
      self._iprot.readMessageEnd()
3022 
      raise x
3064 chandransh 3023 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3024 
    result.read(self._iprot)
3025 
    self._iprot.readMessageEnd()
3431 rajveer 3026 
    if result.success is not None:
1886 ankur.sing 3027 
      return result.success
3064 chandransh 3028 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3029 
 
4783 phani.kuma 3030 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3031 
    """
3032 
    Returns the list of orders whose expected delivery date has passed but have not been
3033 
    delivered yet.
3034 
    Returns an empty list if no such orders exist.
3035 
    """
3036 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3037 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3038 
 
3039 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3040 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3041 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3042 
    args.write(self._oprot)
3043 
    self._oprot.writeMessageEnd()
3044 
    self._oprot.trans.flush()
3045 
 
3046 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3048 
    if mtype == TMessageType.EXCEPTION:
3049 
      x = TApplicationException()
3050 
      x.read(self._iprot)
3051 
      self._iprot.readMessageEnd()
3052 
      raise x
3053 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3054 
    result.read(self._iprot)
3055 
    self._iprot.readMessageEnd()
3056 
    if result.success is not None:
3057 
      return result.success
3058 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3059 
 
2536 chandransh 3060 
  def toggleDOAFlag(self, orderId):
3061 
    """
3062 
    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.
3063 
    Returns the final flag status.
3064 
    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 3065 
 
2536 chandransh 3066 
    Parameters:
3067 
     - orderId
3068 
    """
3069 
    self.send_toggleDOAFlag(orderId)
3070 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3071 
 
2536 chandransh 3072 
  def send_toggleDOAFlag(self, orderId):
3073 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3074 
    args = toggleDOAFlag_args()
3075 
    args.orderId = orderId
3076 
    args.write(self._oprot)
3077 
    self._oprot.writeMessageEnd()
3078 
    self._oprot.trans.flush()
3079 
 
3080 
  def recv_toggleDOAFlag(self, ):
3081 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3082 
    if mtype == TMessageType.EXCEPTION:
3083 
      x = TApplicationException()
3084 
      x.read(self._iprot)
3085 
      self._iprot.readMessageEnd()
3086 
      raise x
3087 
    result = toggleDOAFlag_result()
3088 
    result.read(self._iprot)
3089 
    self._iprot.readMessageEnd()
3431 rajveer 3090 
    if result.success is not None:
2536 chandransh 3091 
      return result.success
3431 rajveer 3092 
    if result.ex is not None:
2536 chandransh 3093 
      raise result.ex
3094 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3095 
 
4712 rajveer 3096 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3097 
    """
3098 
    Parameters:
3099 
     - orderId
3100 
     - deliveryTimestamp
3101 
     - receiver
3102 
    """
3103 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3104 
    self.recv_markOrderAsDelivered()
3105 
 
3106 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3107 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3108 
    args = markOrderAsDelivered_args()
3109 
    args.orderId = orderId
3110 
    args.deliveryTimestamp = deliveryTimestamp
3111 
    args.receiver = receiver
3112 
    args.write(self._oprot)
3113 
    self._oprot.writeMessageEnd()
3114 
    self._oprot.trans.flush()
3115 
 
3116 
  def recv_markOrderAsDelivered(self, ):
3117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3118 
    if mtype == TMessageType.EXCEPTION:
3119 
      x = TApplicationException()
3120 
      x.read(self._iprot)
3121 
      self._iprot.readMessageEnd()
3122 
      raise x
3123 
    result = markOrderAsDelivered_result()
3124 
    result.read(self._iprot)
3125 
    self._iprot.readMessageEnd()
3126 
    if result.ex is not None:
3127 
      raise result.ex
3128 
    return
3129 
 
5553 rajveer 3130 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3131 
    """
3132 
    Parameters:
3133 
     - orderId
3134 
     - deliveryTimestamp
3135 
    """
3136 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3137 
    self.recv_markOrderAsReceivedAtStore()
3138 
 
3139 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3140 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3141 
    args = markOrderAsReceivedAtStore_args()
3142 
    args.orderId = orderId
3143 
    args.deliveryTimestamp = deliveryTimestamp
3144 
    args.write(self._oprot)
3145 
    self._oprot.writeMessageEnd()
3146 
    self._oprot.trans.flush()
3147 
 
3148 
  def recv_markOrderAsReceivedAtStore(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 = markOrderAsReceivedAtStore_result()
3156 
    result.read(self._iprot)
3157 
    self._iprot.readMessageEnd()
3158 
    if result.ex is not None:
3159 
      raise result.ex
3160 
    return
3161 
 
4454 rajveer 3162 
  def markOrderDoaRequestReceived(self, orderId):
3163 
    """
3164 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3165 
 
3166 
    Parameters:
3167 
     - orderId
3168 
    """
3169 
    self.send_markOrderDoaRequestReceived(orderId)
3170 
    return self.recv_markOrderDoaRequestReceived()
3171 
 
3172 
  def send_markOrderDoaRequestReceived(self, orderId):
3173 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3174 
    args = markOrderDoaRequestReceived_args()
3175 
    args.orderId = orderId
3176 
    args.write(self._oprot)
3177 
    self._oprot.writeMessageEnd()
3178 
    self._oprot.trans.flush()
3179 
 
3180 
  def recv_markOrderDoaRequestReceived(self, ):
3181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3182 
    if mtype == TMessageType.EXCEPTION:
3183 
      x = TApplicationException()
3184 
      x.read(self._iprot)
3185 
      self._iprot.readMessageEnd()
3186 
      raise x
3187 
    result = markOrderDoaRequestReceived_result()
3188 
    result.read(self._iprot)
3189 
    self._iprot.readMessageEnd()
3190 
    if result.success is not None:
3191 
      return result.success
3192 
    if result.ex is not None:
3193 
      raise result.ex
3194 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3195 
 
3196 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3197 
    """
3198 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3199 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3200 
 
3201 
    Parameters:
3202 
     - orderId
3203 
     - isAuthorized
3204 
    """
3205 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3206 
    return self.recv_markOrderDoaRequestAuthorized()
3207 
 
3208 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3209 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3210 
    args = markOrderDoaRequestAuthorized_args()
3211 
    args.orderId = orderId
3212 
    args.isAuthorized = isAuthorized
3213 
    args.write(self._oprot)
3214 
    self._oprot.writeMessageEnd()
3215 
    self._oprot.trans.flush()
3216 
 
3217 
  def recv_markOrderDoaRequestAuthorized(self, ):
3218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3219 
    if mtype == TMessageType.EXCEPTION:
3220 
      x = TApplicationException()
3221 
      x.read(self._iprot)
3222 
      self._iprot.readMessageEnd()
3223 
      raise x
3224 
    result = markOrderDoaRequestAuthorized_result()
3225 
    result.read(self._iprot)
3226 
    self._iprot.readMessageEnd()
3227 
    if result.success is not None:
3228 
      return result.success
3229 
    if result.ex is not None:
3230 
      raise result.ex
3231 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3232 
 
4488 rajveer 3233 
  def markOrderReturnRequestReceived(self, orderId):
3234 
    """
3235 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3236 
 
3237 
    Parameters:
3238 
     - orderId
3239 
    """
3240 
    self.send_markOrderReturnRequestReceived(orderId)
3241 
    return self.recv_markOrderReturnRequestReceived()
3242 
 
3243 
  def send_markOrderReturnRequestReceived(self, orderId):
3244 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3245 
    args = markOrderReturnRequestReceived_args()
3246 
    args.orderId = orderId
3247 
    args.write(self._oprot)
3248 
    self._oprot.writeMessageEnd()
3249 
    self._oprot.trans.flush()
3250 
 
3251 
  def recv_markOrderReturnRequestReceived(self, ):
3252 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3253 
    if mtype == TMessageType.EXCEPTION:
3254 
      x = TApplicationException()
3255 
      x.read(self._iprot)
3256 
      self._iprot.readMessageEnd()
3257 
      raise x
3258 
    result = markOrderReturnRequestReceived_result()
3259 
    result.read(self._iprot)
3260 
    self._iprot.readMessageEnd()
3261 
    if result.success is not None:
3262 
      return result.success
3263 
    if result.ex is not None:
3264 
      raise result.ex
3265 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3266 
 
3267 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3268 
    """
3269 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3270 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3271 
 
3272 
    Parameters:
3273 
     - orderId
3274 
     - isAuthorized
3275 
    """
3276 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3277 
    return self.recv_markOrderReturnRequestAuthorized()
3278 
 
3279 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3280 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3281 
    args = markOrderReturnRequestAuthorized_args()
3282 
    args.orderId = orderId
3283 
    args.isAuthorized = isAuthorized
3284 
    args.write(self._oprot)
3285 
    self._oprot.writeMessageEnd()
3286 
    self._oprot.trans.flush()
3287 
 
3288 
  def recv_markOrderReturnRequestAuthorized(self, ):
3289 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3290 
    if mtype == TMessageType.EXCEPTION:
3291 
      x = TApplicationException()
3292 
      x.read(self._iprot)
3293 
      self._iprot.readMessageEnd()
3294 
      raise x
3295 
    result = markOrderReturnRequestAuthorized_result()
3296 
    result.read(self._iprot)
3297 
    self._iprot.readMessageEnd()
3298 
    if result.success is not None:
3299 
      return result.success
3300 
    if result.ex is not None:
3301 
      raise result.ex
3302 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3303 
 
4579 rajveer 3304 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3305 
    """
3306 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3307 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3308 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3309 
    For any other status, it returns false.
3310 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3311 
 
2536 chandransh 3312 
    Parameters:
3313 
     - orderId
4579 rajveer 3314 
     - providerId
2536 chandransh 3315 
    """
4579 rajveer 3316 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3317 
    return self.recv_requestPickupNumber()
3318 
 
4579 rajveer 3319 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3320 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3321 
    args = requestPickupNumber_args()
3322 
    args.orderId = orderId
4579 rajveer 3323 
    args.providerId = providerId
2536 chandransh 3324 
    args.write(self._oprot)
3325 
    self._oprot.writeMessageEnd()
3326 
    self._oprot.trans.flush()
3327 
 
3328 
  def recv_requestPickupNumber(self, ):
3329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3330 
    if mtype == TMessageType.EXCEPTION:
3331 
      x = TApplicationException()
3332 
      x.read(self._iprot)
3333 
      self._iprot.readMessageEnd()
3334 
      raise x
3335 
    result = requestPickupNumber_result()
3336 
    result.read(self._iprot)
3337 
    self._iprot.readMessageEnd()
3431 rajveer 3338 
    if result.success is not None:
2536 chandransh 3339 
      return result.success
3431 rajveer 3340 
    if result.ex is not None:
2536 chandransh 3341 
      raise result.ex
3342 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3343 
 
4602 rajveer 3344 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3345 
    """
4452 rajveer 3346 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3347 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3348 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3349 
    	3. Returns true
2591 chandransh 3350 
    If the order is in any other status, it returns false.
2536 chandransh 3351 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3352 
 
2536 chandransh 3353 
    Parameters:
3354 
     - orderId
3355 
     - pickupNumber
4602 rajveer 3356 
     - providerId
2536 chandransh 3357 
    """
4602 rajveer 3358 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3359 
    return self.recv_authorizePickup()
3360 
 
4602 rajveer 3361 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3362 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3363 
    args = authorizePickup_args()
3364 
    args.orderId = orderId
3365 
    args.pickupNumber = pickupNumber
4602 rajveer 3366 
    args.providerId = providerId
2536 chandransh 3367 
    args.write(self._oprot)
3368 
    self._oprot.writeMessageEnd()
3369 
    self._oprot.trans.flush()
3370 
 
3371 
  def recv_authorizePickup(self, ):
3372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3373 
    if mtype == TMessageType.EXCEPTION:
3374 
      x = TApplicationException()
3375 
      x.read(self._iprot)
3376 
      self._iprot.readMessageEnd()
3377 
      raise x
3378 
    result = authorizePickup_result()
3379 
    result.read(self._iprot)
3380 
    self._iprot.readMessageEnd()
3431 rajveer 3381 
    if result.success is not None:
2536 chandransh 3382 
      return result.success
3431 rajveer 3383 
    if result.ex is not None:
2536 chandransh 3384 
      raise result.ex
3385 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3386 
 
2764 chandransh 3387 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3388 
    """
3389 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3390 
 
2764 chandransh 3391 
    Parameters:
3392 
     - providerId
3393 
     - pickupDetails
3394 
    """
3395 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3396 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3397 
 
3398 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3399 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3400 
    args = markDoasAsPickedUp_args()
3401 
    args.providerId = providerId
3402 
    args.pickupDetails = pickupDetails
3403 
    args.write(self._oprot)
3404 
    self._oprot.writeMessageEnd()
3405 
    self._oprot.trans.flush()
3406 
 
3407 
  def recv_markDoasAsPickedUp(self, ):
3408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3409 
    if mtype == TMessageType.EXCEPTION:
3410 
      x = TApplicationException()
3411 
      x.read(self._iprot)
3412 
      self._iprot.readMessageEnd()
3413 
      raise x
3414 
    result = markDoasAsPickedUp_result()
3415 
    result.read(self._iprot)
3416 
    self._iprot.readMessageEnd()
4910 phani.kuma 3417 
    return
3418 
 
3419 
  def getDoasNotPickedUp(self, providerId):
3420 
    """
3421 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3422 
 
3423 
    Parameters:
3424 
     - providerId
3425 
    """
3426 
    self.send_getDoasNotPickedUp(providerId)
3427 
    return self.recv_getDoasNotPickedUp()
3428 
 
3429 
  def send_getDoasNotPickedUp(self, providerId):
3430 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3431 
    args = getDoasNotPickedUp_args()
3432 
    args.providerId = providerId
3433 
    args.write(self._oprot)
3434 
    self._oprot.writeMessageEnd()
3435 
    self._oprot.trans.flush()
3436 
 
3437 
  def recv_getDoasNotPickedUp(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 = getDoasNotPickedUp_result()
3445 
    result.read(self._iprot)
3446 
    self._iprot.readMessageEnd()
3431 rajveer 3447 
    if result.success is not None:
2764 chandransh 3448 
      return result.success
4910 phani.kuma 3449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3450 
 
4741 phani.kuma 3451 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3452 
    """
3453 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3454 
 
3455 
    Parameters:
3456 
     - providerId
3457 
     - pickupDetails
3458 
    """
3459 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3460 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3461 
 
3462 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3463 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3464 
    args = markReturnOrdersAsPickedUp_args()
3465 
    args.providerId = providerId
3466 
    args.pickupDetails = pickupDetails
3467 
    args.write(self._oprot)
3468 
    self._oprot.writeMessageEnd()
3469 
    self._oprot.trans.flush()
3470 
 
3471 
  def recv_markReturnOrdersAsPickedUp(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 = markReturnOrdersAsPickedUp_result()
3479 
    result.read(self._iprot)
3480 
    self._iprot.readMessageEnd()
4910 phani.kuma 3481 
    return
3482 
 
3483 
  def getReturnOrdersNotPickedUp(self, providerId):
3484 
    """
3485 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3486 
 
3487 
    Parameters:
3488 
     - providerId
3489 
    """
3490 
    self.send_getReturnOrdersNotPickedUp(providerId)
3491 
    return self.recv_getReturnOrdersNotPickedUp()
3492 
 
3493 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3494 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3495 
    args = getReturnOrdersNotPickedUp_args()
3496 
    args.providerId = providerId
3497 
    args.write(self._oprot)
3498 
    self._oprot.writeMessageEnd()
3499 
    self._oprot.trans.flush()
3500 
 
3501 
  def recv_getReturnOrdersNotPickedUp(self, ):
3502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3503 
    if mtype == TMessageType.EXCEPTION:
3504 
      x = TApplicationException()
3505 
      x.read(self._iprot)
3506 
      self._iprot.readMessageEnd()
3507 
      raise x
3508 
    result = getReturnOrdersNotPickedUp_result()
3509 
    result.read(self._iprot)
3510 
    self._iprot.readMessageEnd()
4741 phani.kuma 3511 
    if result.success is not None:
3512 
      return result.success
4910 phani.kuma 3513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3514 
 
4479 rajveer 3515 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3516 
    """
4452 rajveer 3517 
    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 3518 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3519 
    If the order is in any other state, it returns false.
3520 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3521 
 
2591 chandransh 3522 
    Parameters:
3523 
     - orderId
4479 rajveer 3524 
     - receiveCondition
2591 chandransh 3525 
    """
4479 rajveer 3526 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3527 
    return self.recv_receiveReturn()
2536 chandransh 3528 
 
4479 rajveer 3529 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3530 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3531 
    args = receiveReturn_args()
2591 chandransh 3532 
    args.orderId = orderId
4479 rajveer 3533 
    args.receiveCondition = receiveCondition
2591 chandransh 3534 
    args.write(self._oprot)
3535 
    self._oprot.writeMessageEnd()
3536 
    self._oprot.trans.flush()
3537 
 
2616 chandransh 3538 
  def recv_receiveReturn(self, ):
2591 chandransh 3539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3540 
    if mtype == TMessageType.EXCEPTION:
3541 
      x = TApplicationException()
3542 
      x.read(self._iprot)
3543 
      self._iprot.readMessageEnd()
3544 
      raise x
2616 chandransh 3545 
    result = receiveReturn_result()
2591 chandransh 3546 
    result.read(self._iprot)
3547 
    self._iprot.readMessageEnd()
3431 rajveer 3548 
    if result.success is not None:
2591 chandransh 3549 
      return result.success
3431 rajveer 3550 
    if result.ex is not None:
2591 chandransh 3551 
      raise result.ex
2616 chandransh 3552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3553 
 
3554 
  def validateDoa(self, orderId, isValid):
3555 
    """
4452 rajveer 3556 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3557 
    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 3558 
    If the order is in any other state, it returns false.
3559 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3560 
 
2591 chandransh 3561 
    Parameters:
3562 
     - orderId
3563 
     - isValid
3564 
    """
3565 
    self.send_validateDoa(orderId, isValid)
3566 
    return self.recv_validateDoa()
3567 
 
3568 
  def send_validateDoa(self, orderId, isValid):
3569 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3570 
    args = validateDoa_args()
3571 
    args.orderId = orderId
3572 
    args.isValid = isValid
3573 
    args.write(self._oprot)
3574 
    self._oprot.writeMessageEnd()
3575 
    self._oprot.trans.flush()
3576 
 
3577 
  def recv_validateDoa(self, ):
3578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3579 
    if mtype == TMessageType.EXCEPTION:
3580 
      x = TApplicationException()
3581 
      x.read(self._iprot)
3582 
      self._iprot.readMessageEnd()
3583 
      raise x
3584 
    result = validateDoa_result()
3585 
    result.read(self._iprot)
3586 
    self._iprot.readMessageEnd()
3431 rajveer 3587 
    if result.success is not None:
2591 chandransh 3588 
      return result.success
3431 rajveer 3589 
    if result.ex is not None:
2591 chandransh 3590 
      raise result.ex
3591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3592 
 
4495 rajveer 3593 
  def validateReturnProduct(self, orderId, isUsable):
3594 
    """
3595 
    Parameters:
3596 
     - orderId
3597 
     - isUsable
3598 
    """
3599 
    self.send_validateReturnProduct(orderId, isUsable)
3600 
    return self.recv_validateReturnProduct()
3601 
 
3602 
  def send_validateReturnProduct(self, orderId, isUsable):
3603 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3604 
    args = validateReturnProduct_args()
3605 
    args.orderId = orderId
3606 
    args.isUsable = isUsable
3607 
    args.write(self._oprot)
3608 
    self._oprot.writeMessageEnd()
3609 
    self._oprot.trans.flush()
3610 
 
3611 
  def recv_validateReturnProduct(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 = validateReturnProduct_result()
3619 
    result.read(self._iprot)
3620 
    self._iprot.readMessageEnd()
3621 
    if result.success is not None:
3622 
      return result.success
3623 
    if result.ex is not None:
3624 
      raise result.ex
3625 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3626 
 
2616 chandransh 3627 
  def reshipOrder(self, orderId):
3628 
    """
4484 rajveer 3629 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3630 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3631 
    	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 3632 
 
3633 
    If the order is in DOA_CERT_VALID state, it does the following:
3634 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3635 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3636 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3637 
 
2616 chandransh 3638 
    Returns the id of the newly created order.
3431 rajveer 3639 
 
2616 chandransh 3640 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3641 
 
2616 chandransh 3642 
    Parameters:
3643 
     - orderId
3644 
    """
3645 
    self.send_reshipOrder(orderId)
3646 
    return self.recv_reshipOrder()
2591 chandransh 3647 
 
2616 chandransh 3648 
  def send_reshipOrder(self, orderId):
3649 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3650 
    args = reshipOrder_args()
3651 
    args.orderId = orderId
3652 
    args.write(self._oprot)
3653 
    self._oprot.writeMessageEnd()
3654 
    self._oprot.trans.flush()
3655 
 
3656 
  def recv_reshipOrder(self, ):
3657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3658 
    if mtype == TMessageType.EXCEPTION:
3659 
      x = TApplicationException()
3660 
      x.read(self._iprot)
3661 
      self._iprot.readMessageEnd()
3662 
      raise x
3663 
    result = reshipOrder_result()
3664 
    result.read(self._iprot)
3665 
    self._iprot.readMessageEnd()
3431 rajveer 3666 
    if result.success is not None:
2616 chandransh 3667 
      return result.success
3431 rajveer 3668 
    if result.ex is not None:
2616 chandransh 3669 
      raise result.ex
3670 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3671 
 
3226 chandransh 3672 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3673 
    """
4484 rajveer 3674 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3675 
    	1. Creates a refund request for batch processing.
3676 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3677 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3678 
 
2616 chandransh 3679 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3680 
    	1. Creates a refund request for batch processing.
3226 chandransh 3681 
    	2. Cancels the reservation of the item in the warehouse.
3682 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3683 
 
3226 chandransh 3684 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3685 
    	1. Cancels the reservation of the item in the warehouse.
3686 
    	2. Marks the current order as CANCELED.
3687 
 
3688 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3689 
 
2616 chandransh 3690 
    Returns True if it is successful, False otherwise.
3431 rajveer 3691 
 
2616 chandransh 3692 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3693 
 
2616 chandransh 3694 
    Parameters:
3695 
     - orderId
3226 chandransh 3696 
     - refundedBy
3697 
     - reason
2616 chandransh 3698 
    """
3226 chandransh 3699 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3700 
    return self.recv_refundOrder()
3701 
 
3226 chandransh 3702 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3703 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3704 
    args = refundOrder_args()
3705 
    args.orderId = orderId
3226 chandransh 3706 
    args.refundedBy = refundedBy
3707 
    args.reason = reason
2616 chandransh 3708 
    args.write(self._oprot)
3709 
    self._oprot.writeMessageEnd()
3710 
    self._oprot.trans.flush()
3711 
 
3712 
  def recv_refundOrder(self, ):
3713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3714 
    if mtype == TMessageType.EXCEPTION:
3715 
      x = TApplicationException()
3716 
      x.read(self._iprot)
3717 
      self._iprot.readMessageEnd()
3718 
      raise x
3719 
    result = refundOrder_result()
3720 
    result.read(self._iprot)
3721 
    self._iprot.readMessageEnd()
3431 rajveer 3722 
    if result.success is not None:
2616 chandransh 3723 
      return result.success
3431 rajveer 3724 
    if result.ex is not None:
2616 chandransh 3725 
      raise result.ex
3726 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3727 
 
2690 chandransh 3728 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3729 
    """
3730 
    Get all return orders created between the from and to dates for the given warehouse.
3731 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3732 
 
2690 chandransh 3733 
    Parameters:
3734 
     - warehouseId
3735 
     - fromDate
3736 
     - toDate
3737 
    """
3738 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3739 
    return self.recv_getReturnOrders()
2616 chandransh 3740 
 
2690 chandransh 3741 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3742 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3743 
    args = getReturnOrders_args()
3744 
    args.warehouseId = warehouseId
3745 
    args.fromDate = fromDate
3746 
    args.toDate = toDate
3747 
    args.write(self._oprot)
3748 
    self._oprot.writeMessageEnd()
3749 
    self._oprot.trans.flush()
3750 
 
3751 
  def recv_getReturnOrders(self, ):
3752 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3753 
    if mtype == TMessageType.EXCEPTION:
3754 
      x = TApplicationException()
3755 
      x.read(self._iprot)
3756 
      self._iprot.readMessageEnd()
3757 
      raise x
3758 
    result = getReturnOrders_result()
3759 
    result.read(self._iprot)
3760 
    self._iprot.readMessageEnd()
3431 rajveer 3761 
    if result.success is not None:
2690 chandransh 3762 
      return result.success
3763 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3764 
 
5481 phani.kuma 3765 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3766 
    """
3767 
    Get all return orders created between the from and to dates.
3768 
 
3769 
    Parameters:
3770 
     - onlyNotProcessed
3771 
     - fromDate
3772 
     - toDate
3773 
    """
3774 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3775 
    return self.recv_getAllReturnOrders()
3776 
 
3777 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3778 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3779 
    args = getAllReturnOrders_args()
3780 
    args.onlyNotProcessed = onlyNotProcessed
3781 
    args.fromDate = fromDate
3782 
    args.toDate = toDate
3783 
    args.write(self._oprot)
3784 
    self._oprot.writeMessageEnd()
3785 
    self._oprot.trans.flush()
3786 
 
3787 
  def recv_getAllReturnOrders(self, ):
3788 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3789 
    if mtype == TMessageType.EXCEPTION:
3790 
      x = TApplicationException()
3791 
      x.read(self._iprot)
3792 
      self._iprot.readMessageEnd()
3793 
      raise x
3794 
    result = getAllReturnOrders_result()
3795 
    result.read(self._iprot)
3796 
    self._iprot.readMessageEnd()
3797 
    if result.success is not None:
3798 
      return result.success
3799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3800 
 
2700 chandransh 3801 
  def getReturnOrder(self, id):
3802 
    """
3803 
    Returns the ReturnOrder corresponding to the given id.
3804 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3805 
 
2700 chandransh 3806 
    Parameters:
3807 
     - id
3808 
    """
3809 
    self.send_getReturnOrder(id)
3810 
    return self.recv_getReturnOrder()
3811 
 
3812 
  def send_getReturnOrder(self, id):
3813 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3814 
    args = getReturnOrder_args()
3815 
    args.id = id
3816 
    args.write(self._oprot)
3817 
    self._oprot.writeMessageEnd()
3818 
    self._oprot.trans.flush()
3819 
 
3820 
  def recv_getReturnOrder(self, ):
3821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3822 
    if mtype == TMessageType.EXCEPTION:
3823 
      x = TApplicationException()
3824 
      x.read(self._iprot)
3825 
      self._iprot.readMessageEnd()
3826 
      raise x
3827 
    result = getReturnOrder_result()
3828 
    result.read(self._iprot)
3829 
    self._iprot.readMessageEnd()
3431 rajveer 3830 
    if result.success is not None:
2700 chandransh 3831 
      return result.success
3431 rajveer 3832 
    if result.ex is not None:
2700 chandransh 3833 
      raise result.ex
3834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3835 
 
2690 chandransh 3836 
  def processReturn(self, returnOrderId):
3837 
    """
3838 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3839 
 
2690 chandransh 3840 
    Parameters:
3841 
     - returnOrderId
3842 
    """
3843 
    self.send_processReturn(returnOrderId)
3844 
    self.recv_processReturn()
3845 
 
3846 
  def send_processReturn(self, returnOrderId):
3847 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3848 
    args = processReturn_args()
3849 
    args.returnOrderId = returnOrderId
3850 
    args.write(self._oprot)
3851 
    self._oprot.writeMessageEnd()
3852 
    self._oprot.trans.flush()
3853 
 
3854 
  def recv_processReturn(self, ):
3855 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3856 
    if mtype == TMessageType.EXCEPTION:
3857 
      x = TApplicationException()
3858 
      x.read(self._iprot)
3859 
      self._iprot.readMessageEnd()
3860 
      raise x
3861 
    result = processReturn_result()
3862 
    result.read(self._iprot)
3863 
    self._iprot.readMessageEnd()
3431 rajveer 3864 
    if result.ex is not None:
2690 chandransh 3865 
      raise result.ex
3866 
    return
3867 
 
3451 chandransh 3868 
  def updateWeight(self, orderId, weight):
3869 
    """
3870 
    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 3871 
 
3451 chandransh 3872 
    Parameters:
3873 
     - orderId
3874 
     - weight
3875 
    """
3876 
    self.send_updateWeight(orderId, weight)
3877 
    return self.recv_updateWeight()
3878 
 
3879 
  def send_updateWeight(self, orderId, weight):
3880 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3881 
    args = updateWeight_args()
3882 
    args.orderId = orderId
3883 
    args.weight = weight
3884 
    args.write(self._oprot)
3885 
    self._oprot.writeMessageEnd()
3886 
    self._oprot.trans.flush()
3887 
 
3888 
  def recv_updateWeight(self, ):
3889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3890 
    if mtype == TMessageType.EXCEPTION:
3891 
      x = TApplicationException()
3892 
      x.read(self._iprot)
3893 
      self._iprot.readMessageEnd()
3894 
      raise x
3895 
    result = updateWeight_result()
3896 
    result.read(self._iprot)
3897 
    self._iprot.readMessageEnd()
3898 
    if result.success is not None:
3899 
      return result.success
3900 
    if result.ex is not None:
3901 
      raise result.ex
3902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3903 
 
3469 chandransh 3904 
  def changeItem(self, orderId, itemId):
3905 
    """
3906 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3907 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3908 
 
3469 chandransh 3909 
    Parameters:
3910 
     - orderId
3911 
     - itemId
3912 
    """
3913 
    self.send_changeItem(orderId, itemId)
3914 
    return self.recv_changeItem()
3915 
 
3916 
  def send_changeItem(self, orderId, itemId):
3917 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3918 
    args = changeItem_args()
3919 
    args.orderId = orderId
3920 
    args.itemId = itemId
3921 
    args.write(self._oprot)
3922 
    self._oprot.writeMessageEnd()
3923 
    self._oprot.trans.flush()
3924 
 
3925 
  def recv_changeItem(self, ):
3926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3927 
    if mtype == TMessageType.EXCEPTION:
3928 
      x = TApplicationException()
3929 
      x.read(self._iprot)
3930 
      self._iprot.readMessageEnd()
3931 
      raise x
3932 
    result = changeItem_result()
3933 
    result.read(self._iprot)
3934 
    self._iprot.readMessageEnd()
3935 
    if result.success is not None:
3936 
      return result.success
3937 
    if result.ex is not None:
3938 
      raise result.ex
3939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3940 
 
3941 
  def shiftToWarehouse(self, orderId, warehouseId):
3942 
    """
3943 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3944 
 
3945 
    Parameters:
3946 
     - orderId
3947 
     - warehouseId
3948 
    """
3949 
    self.send_shiftToWarehouse(orderId, warehouseId)
3950 
    return self.recv_shiftToWarehouse()
3951 
 
3952 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3953 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3954 
    args = shiftToWarehouse_args()
3955 
    args.orderId = orderId
3956 
    args.warehouseId = warehouseId
3957 
    args.write(self._oprot)
3958 
    self._oprot.writeMessageEnd()
3959 
    self._oprot.trans.flush()
3960 
 
3961 
  def recv_shiftToWarehouse(self, ):
3962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3963 
    if mtype == TMessageType.EXCEPTION:
3964 
      x = TApplicationException()
3965 
      x.read(self._iprot)
3966 
      self._iprot.readMessageEnd()
3967 
      raise x
3968 
    result = shiftToWarehouse_result()
3969 
    result.read(self._iprot)
3970 
    self._iprot.readMessageEnd()
3971 
    if result.success is not None:
3972 
      return result.success
3973 
    if result.ex is not None:
3974 
      raise result.ex
3975 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3976 
 
4647 rajveer 3977 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3978 
    """
3979 
    Adds the given delay reason to the given order.
3986 chandransh 3980 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3981 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3982 
 
3553 chandransh 3983 
    Parameters:
3984 
     - orderId
3985 
     - delayReason
3986 chandransh 3986 
     - furtherDelay
4647 rajveer 3987 
     - delayReasonText
3553 chandransh 3988 
    """
4647 rajveer 3989 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3990 
    return self.recv_addDelayReason()
3991 
 
4647 rajveer 3992 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3993 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3994 
    args = addDelayReason_args()
3995 
    args.orderId = orderId
3996 
    args.delayReason = delayReason
3986 chandransh 3997 
    args.furtherDelay = furtherDelay
4647 rajveer 3998 
    args.delayReasonText = delayReasonText
3553 chandransh 3999 
    args.write(self._oprot)
4000 
    self._oprot.writeMessageEnd()
4001 
    self._oprot.trans.flush()
4002 
 
4003 
  def recv_addDelayReason(self, ):
4004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4005 
    if mtype == TMessageType.EXCEPTION:
4006 
      x = TApplicationException()
4007 
      x.read(self._iprot)
4008 
      self._iprot.readMessageEnd()
4009 
      raise x
4010 
    result = addDelayReason_result()
4011 
    result.read(self._iprot)
4012 
    self._iprot.readMessageEnd()
4013 
    if result.success is not None:
4014 
      return result.success
4015 
    if result.ex is not None:
4016 
      raise result.ex
4017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4018 
 
3956 chandransh 4019 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4020 
    """
4021 
    Marks the COD orders with given AWB nos. as having been processed.
4022 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4023 
 
3956 chandransh 4024 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4025 
    1. There is no order corresponding to an AWB number.
4026 
    2. The captured amount for a payment exceeds the total payment.
4027 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4028 
 
4029 
    Parameters:
4030 
     - collectedAmountMap
4031 
     - xferBy
4032 
     - xferTxnId
4033 
     - xferDate
4034 
    """
4035 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4036 
    return self.recv_reconcileCodCollection()
4037 
 
4038 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4039 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4040 
    args = reconcileCodCollection_args()
4041 
    args.collectedAmountMap = collectedAmountMap
4042 
    args.xferBy = xferBy
4043 
    args.xferTxnId = xferTxnId
4044 
    args.xferDate = xferDate
4045 
    args.write(self._oprot)
4046 
    self._oprot.writeMessageEnd()
4047 
    self._oprot.trans.flush()
4048 
 
4049 
  def recv_reconcileCodCollection(self, ):
4050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4051 
    if mtype == TMessageType.EXCEPTION:
4052 
      x = TApplicationException()
4053 
      x.read(self._iprot)
4054 
      self._iprot.readMessageEnd()
4055 
      raise x
4056 
    result = reconcileCodCollection_result()
4057 
    result.read(self._iprot)
4058 
    self._iprot.readMessageEnd()
4059 
    if result.success is not None:
4060 
      return result.success
4061 
    if result.ex is not None:
4062 
      raise result.ex
4063 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4064 
 
4008 mandeep.dh 4065 
  def getTransactionsRequiringExtraProcessing(self, category):
4066 
    """
4065 mandeep.dh 4067 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4068 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4069 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4070 
 
4008 mandeep.dh 4071 
    Parameters:
4072 
     - category
4073 
    """
4074 
    self.send_getTransactionsRequiringExtraProcessing(category)
4075 
    return self.recv_getTransactionsRequiringExtraProcessing()
4076 
 
4077 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4078 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4079 
    args = getTransactionsRequiringExtraProcessing_args()
4080 
    args.category = category
4081 
    args.write(self._oprot)
4082 
    self._oprot.writeMessageEnd()
4083 
    self._oprot.trans.flush()
4084 
 
4085 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4086 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4087 
    if mtype == TMessageType.EXCEPTION:
4088 
      x = TApplicationException()
4089 
      x.read(self._iprot)
4090 
      self._iprot.readMessageEnd()
4091 
      raise x
4092 
    result = getTransactionsRequiringExtraProcessing_result()
4093 
    result.read(self._iprot)
4094 
    self._iprot.readMessageEnd()
4095 
    if result.success is not None:
4096 
      return result.success
4097 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4098 
 
4099 
  def markTransactionAsProcessed(self, transactionId, category):
4100 
    """
4101 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4102 
    It essentially deletes the transaction id record for a particular
4103 
    processing type category (if present) from DB.
4104 
    This is currently used by CRM application.
4008 mandeep.dh 4105 
 
4106 
    Parameters:
4107 
     - transactionId
4108 
     - category
4109 
    """
4110 
    self.send_markTransactionAsProcessed(transactionId, category)
4111 
    self.recv_markTransactionAsProcessed()
4112 
 
4113 
  def send_markTransactionAsProcessed(self, transactionId, category):
4114 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4115 
    args = markTransactionAsProcessed_args()
4116 
    args.transactionId = transactionId
4117 
    args.category = category
4118 
    args.write(self._oprot)
4119 
    self._oprot.writeMessageEnd()
4120 
    self._oprot.trans.flush()
4121 
 
4122 
  def recv_markTransactionAsProcessed(self, ):
4123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4124 
    if mtype == TMessageType.EXCEPTION:
4125 
      x = TApplicationException()
4126 
      x.read(self._iprot)
4127 
      self._iprot.readMessageEnd()
4128 
      raise x
4129 
    result = markTransactionAsProcessed_result()
4130 
    result.read(self._iprot)
4131 
    self._iprot.readMessageEnd()
4132 
    return
4133 
 
4018 chandransh 4134 
  def getItemWiseRiskyOrdersCount(self, ):
4135 
    """
4136 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4137 
    is defined as one whose shipping date is about to expire.
4138 
    """
4139 
    self.send_getItemWiseRiskyOrdersCount()
4140 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4141 
 
4018 chandransh 4142 
  def send_getItemWiseRiskyOrdersCount(self, ):
4143 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4144 
    args = getItemWiseRiskyOrdersCount_args()
4145 
    args.write(self._oprot)
4146 
    self._oprot.writeMessageEnd()
4147 
    self._oprot.trans.flush()
4148 
 
4149 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4150 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4151 
    if mtype == TMessageType.EXCEPTION:
4152 
      x = TApplicationException()
4153 
      x.read(self._iprot)
4154 
      self._iprot.readMessageEnd()
4155 
      raise x
4156 
    result = getItemWiseRiskyOrdersCount_result()
4157 
    result.read(self._iprot)
4158 
    self._iprot.readMessageEnd()
4159 
    if result.success is not None:
4160 
      return result.success
4161 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4162 
 
4295 varun.gupt 4163 
  def getOrdersForItemIds(self, itemIds):
4164 
    """
4165 
    Returns a list of all orders which have items with given id
4166 
 
4167 
    Parameters:
4168 
     - itemIds
4169 
    """
4170 
    self.send_getOrdersForItemIds(itemIds)
4171 
    return self.recv_getOrdersForItemIds()
4172 
 
4173 
  def send_getOrdersForItemIds(self, itemIds):
4174 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4175 
    args = getOrdersForItemIds_args()
4176 
    args.itemIds = itemIds
4177 
    args.write(self._oprot)
4178 
    self._oprot.writeMessageEnd()
4179 
    self._oprot.trans.flush()
4180 
 
4181 
  def recv_getOrdersForItemIds(self, ):
4182 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4183 
    if mtype == TMessageType.EXCEPTION:
4184 
      x = TApplicationException()
4185 
      x.read(self._iprot)
4186 
      self._iprot.readMessageEnd()
4187 
      raise x
4188 
    result = getOrdersForItemIds_result()
4189 
    result.read(self._iprot)
4190 
    self._iprot.readMessageEnd()
4191 
    if result.success is not None:
4192 
      return result.success
4193 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4194 
 
4247 rajveer 4195 
  def markOrderCancellationRequestReceived(self, orderId):
4196 
    """
4197 
    Mark order as cancellation request received. If customer sends request of cancellation of
4198 
    a particular order, this method will be called. It will just change status of the order
4199 
    depending on its current status. It also records the previous status, so that we can move
4200 
    back to that status if cancellation request is denied.
4018 chandransh 4201 
 
4247 rajveer 4202 
    Parameters:
4203 
     - orderId
4204 
    """
4205 
    self.send_markOrderCancellationRequestReceived(orderId)
4206 
    self.recv_markOrderCancellationRequestReceived()
4207 
 
4208 
  def send_markOrderCancellationRequestReceived(self, orderId):
4209 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4210 
    args = markOrderCancellationRequestReceived_args()
4211 
    args.orderId = orderId
4212 
    args.write(self._oprot)
4213 
    self._oprot.writeMessageEnd()
4214 
    self._oprot.trans.flush()
4215 
 
4216 
  def recv_markOrderCancellationRequestReceived(self, ):
4217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4218 
    if mtype == TMessageType.EXCEPTION:
4219 
      x = TApplicationException()
4220 
      x.read(self._iprot)
4221 
      self._iprot.readMessageEnd()
4222 
      raise x
4223 
    result = markOrderCancellationRequestReceived_result()
4224 
    result.read(self._iprot)
4225 
    self._iprot.readMessageEnd()
4226 
    if result.ex is not None:
4227 
      raise result.ex
4228 
    return
4229 
 
4230 
  def markOrderCancellationRequestConfirmed(self, orderId):
4231 
    """
4232 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4233 
    cancellation request confirmed. After this OM will be able to cancel the order.
4234 
 
4235 
    Parameters:
4236 
     - orderId
4237 
    """
4238 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4239 
    self.recv_markOrderCancellationRequestConfirmed()
4240 
 
4241 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4242 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4243 
    args = markOrderCancellationRequestConfirmed_args()
4244 
    args.orderId = orderId
4245 
    args.write(self._oprot)
4246 
    self._oprot.writeMessageEnd()
4247 
    self._oprot.trans.flush()
4248 
 
4249 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4250 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4251 
    if mtype == TMessageType.EXCEPTION:
4252 
      x = TApplicationException()
4253 
      x.read(self._iprot)
4254 
      self._iprot.readMessageEnd()
4255 
      raise x
4256 
    result = markOrderCancellationRequestConfirmed_result()
4257 
    result.read(self._iprot)
4258 
    self._iprot.readMessageEnd()
4259 
    if result.ex is not None:
4260 
      raise result.ex
4261 
    return
4262 
 
4263 
  def markOrderCancellationRequestDenied(self, orderId):
4264 
    """
4265 
    If we decide to not to cancel order, we will move the order ro previous status.
4266 
 
4267 
    Parameters:
4268 
     - orderId
4269 
    """
4270 
    self.send_markOrderCancellationRequestDenied(orderId)
4271 
    self.recv_markOrderCancellationRequestDenied()
4272 
 
4273 
  def send_markOrderCancellationRequestDenied(self, orderId):
4274 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4275 
    args = markOrderCancellationRequestDenied_args()
4276 
    args.orderId = orderId
4277 
    args.write(self._oprot)
4278 
    self._oprot.writeMessageEnd()
4279 
    self._oprot.trans.flush()
4280 
 
4281 
  def recv_markOrderCancellationRequestDenied(self, ):
4282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4283 
    if mtype == TMessageType.EXCEPTION:
4284 
      x = TApplicationException()
4285 
      x.read(self._iprot)
4286 
      self._iprot.readMessageEnd()
4287 
      raise x
4288 
    result = markOrderCancellationRequestDenied_result()
4289 
    result.read(self._iprot)
4290 
    self._iprot.readMessageEnd()
4291 
    if result.ex is not None:
4292 
      raise result.ex
4293 
    return
4294 
 
4258 rajveer 4295 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4296 
    """
4258 rajveer 4297 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4298 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4299 
 
4300 
    Parameters:
4258 rajveer 4301 
     - transactionId
4247 rajveer 4302 
    """
4258 rajveer 4303 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4304 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4305 
 
4258 rajveer 4306 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4307 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4308 
    args = markTransactionAsPaymentFlagRemoved_args()
4309 
    args.transactionId = transactionId
4247 rajveer 4310 
    args.write(self._oprot)
4311 
    self._oprot.writeMessageEnd()
4312 
    self._oprot.trans.flush()
4313 
 
4258 rajveer 4314 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4315 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4316 
    if mtype == TMessageType.EXCEPTION:
4317 
      x = TApplicationException()
4318 
      x.read(self._iprot)
4319 
      self._iprot.readMessageEnd()
4320 
      raise x
4258 rajveer 4321 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4322 
    result.read(self._iprot)
4323 
    self._iprot.readMessageEnd()
4324 
    if result.ex is not None:
4325 
      raise result.ex
4326 
    return
4327 
 
4259 anupam.sin 4328 
  def refundTransaction(self, transactionId, refundedBy, reason):
4329 
    """
4330 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4331 
    need to be cancelled
4247 rajveer 4332 
 
4259 anupam.sin 4333 
    Parameters:
4334 
     - transactionId
4335 
     - refundedBy
4336 
     - reason
4337 
    """
4338 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4339 
    self.recv_refundTransaction()
4340 
 
4341 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4342 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4343 
    args = refundTransaction_args()
4344 
    args.transactionId = transactionId
4345 
    args.refundedBy = refundedBy
4346 
    args.reason = reason
4347 
    args.write(self._oprot)
4348 
    self._oprot.writeMessageEnd()
4349 
    self._oprot.trans.flush()
4350 
 
4351 
  def recv_refundTransaction(self, ):
4352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4353 
    if mtype == TMessageType.EXCEPTION:
4354 
      x = TApplicationException()
4355 
      x.read(self._iprot)
4356 
      self._iprot.readMessageEnd()
4357 
      raise x
4358 
    result = refundTransaction_result()
4359 
    result.read(self._iprot)
4360 
    self._iprot.readMessageEnd()
4361 
    if result.ex is not None:
4362 
      raise result.ex
4363 
    return
4364 
 
4324 mandeep.dh 4365 
  def updateShipmentAddress(self, orderId, addressId):
4366 
    """
4367 
    Updates shipment address of an order. Delivery and shipping date estimates
4368 
    etc. are also updated here.
4369 
 
4370 
    Throws TransactionServiceException in case address change is not
4371 
    possible due to certain reasons such as new pincode in address is
4372 
    not serviceable etc.
4373 
 
4374 
    Parameters:
4375 
     - orderId
4376 
     - addressId
4377 
    """
4378 
    self.send_updateShipmentAddress(orderId, addressId)
4379 
    self.recv_updateShipmentAddress()
4380 
 
4381 
  def send_updateShipmentAddress(self, orderId, addressId):
4382 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4383 
    args = updateShipmentAddress_args()
4384 
    args.orderId = orderId
4385 
    args.addressId = addressId
4386 
    args.write(self._oprot)
4387 
    self._oprot.writeMessageEnd()
4388 
    self._oprot.trans.flush()
4389 
 
4390 
  def recv_updateShipmentAddress(self, ):
4391 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4392 
    if mtype == TMessageType.EXCEPTION:
4393 
      x = TApplicationException()
4394 
      x.read(self._iprot)
4395 
      self._iprot.readMessageEnd()
4396 
      raise x
4397 
    result = updateShipmentAddress_result()
4398 
    result.read(self._iprot)
4399 
    self._iprot.readMessageEnd()
4400 
    if result.ex is not None:
4401 
      raise result.ex
4402 
    return
4403 
 
4285 rajveer 4404 
  def acceptOrdersForItemId(self, itemId, inventory):
4405 
    """
4406 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4407 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4408 
 
4285 rajveer 4409 
    Parameters:
4410 
     - itemId
4411 
     - inventory
4412 
    """
4413 
    self.send_acceptOrdersForItemId(itemId, inventory)
4414 
    return self.recv_acceptOrdersForItemId()
4415 
 
4416 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4417 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4418 
    args = acceptOrdersForItemId_args()
4419 
    args.itemId = itemId
4420 
    args.inventory = inventory
4421 
    args.write(self._oprot)
4422 
    self._oprot.writeMessageEnd()
4423 
    self._oprot.trans.flush()
4424 
 
4425 
  def recv_acceptOrdersForItemId(self, ):
4426 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4427 
    if mtype == TMessageType.EXCEPTION:
4428 
      x = TApplicationException()
4429 
      x.read(self._iprot)
4430 
      self._iprot.readMessageEnd()
4431 
      raise x
4432 
    result = acceptOrdersForItemId_result()
4433 
    result.read(self._iprot)
4434 
    self._iprot.readMessageEnd()
4435 
    if result.success is not None:
4436 
      return result.success
4437 
    if result.ex is not None:
4438 
      raise result.ex
4439 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4440 
 
4369 rajveer 4441 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4442 
    """
4443 
    Parameters:
4444 
     - vendorId
4445 
     - itemId
4446 
     - quantity
4447 
     - estimate
4369 rajveer 4448 
     - isReminder
4303 rajveer 4449 
    """
4369 rajveer 4450 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4451 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4452 
 
4369 rajveer 4453 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4454 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4455 
    args = markOrdersAsPORaised_args()
4456 
    args.vendorId = vendorId
4457 
    args.itemId = itemId
4458 
    args.quantity = quantity
4459 
    args.estimate = estimate
4369 rajveer 4460 
    args.isReminder = isReminder
4303 rajveer 4461 
    args.write(self._oprot)
4462 
    self._oprot.writeMessageEnd()
4463 
    self._oprot.trans.flush()
4464 
 
4465 
  def recv_markOrdersAsPORaised(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 = markOrdersAsPORaised_result()
4473 
    result.read(self._iprot)
4474 
    self._iprot.readMessageEnd()
4475 
    if result.ex is not None:
4476 
      raise result.ex
4477 
    return
4478 
 
4369 rajveer 4479 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4480 
    """
4481 
    Parameters:
4482 
     - vendorId
4483 
     - itemId
4484 
     - quantity
4485 
     - estimate
4369 rajveer 4486 
     - isReminder
4303 rajveer 4487 
    """
4369 rajveer 4488 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4489 
    self.recv_markOrdersAsReversalInitiated()
4490 
 
4369 rajveer 4491 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4492 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4493 
    args = markOrdersAsReversalInitiated_args()
4494 
    args.vendorId = vendorId
4495 
    args.itemId = itemId
4496 
    args.quantity = quantity
4497 
    args.estimate = estimate
4369 rajveer 4498 
    args.isReminder = isReminder
4303 rajveer 4499 
    args.write(self._oprot)
4500 
    self._oprot.writeMessageEnd()
4501 
    self._oprot.trans.flush()
4502 
 
4503 
  def recv_markOrdersAsReversalInitiated(self, ):
4504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4505 
    if mtype == TMessageType.EXCEPTION:
4506 
      x = TApplicationException()
4507 
      x.read(self._iprot)
4508 
      self._iprot.readMessageEnd()
4509 
      raise x
4510 
    result = markOrdersAsReversalInitiated_result()
4511 
    result.read(self._iprot)
4512 
    self._iprot.readMessageEnd()
4513 
    if result.ex is not None:
4514 
      raise result.ex
4515 
    return
4516 
 
4369 rajveer 4517 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4518 
    """
4519 
    Parameters:
4520 
     - vendorId
4521 
     - itemId
4522 
     - quantity
4523 
     - estimate
4369 rajveer 4524 
     - isReminder
4303 rajveer 4525 
    """
4369 rajveer 4526 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4527 
    self.recv_markOrdersAsNotAvailabke()
4528 
 
4369 rajveer 4529 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4530 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4531 
    args = markOrdersAsNotAvailabke_args()
4532 
    args.vendorId = vendorId
4533 
    args.itemId = itemId
4534 
    args.quantity = quantity
4535 
    args.estimate = estimate
4369 rajveer 4536 
    args.isReminder = isReminder
4303 rajveer 4537 
    args.write(self._oprot)
4538 
    self._oprot.writeMessageEnd()
4539 
    self._oprot.trans.flush()
4540 
 
4541 
  def recv_markOrdersAsNotAvailabke(self, ):
4542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4543 
    if mtype == TMessageType.EXCEPTION:
4544 
      x = TApplicationException()
4545 
      x.read(self._iprot)
4546 
      self._iprot.readMessageEnd()
4547 
      raise x
4548 
    result = markOrdersAsNotAvailabke_result()
4549 
    result.read(self._iprot)
4550 
    self._iprot.readMessageEnd()
4551 
    if result.ex is not None:
4552 
      raise result.ex
4553 
    return
4554 
 
4369 rajveer 4555 
  def markOrdersAsTimeout(self, vendorId):
4556 
    """
4557 
    Parameters:
4558 
     - vendorId
4559 
    """
4560 
    self.send_markOrdersAsTimeout(vendorId)
4561 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4562 
 
4369 rajveer 4563 
  def send_markOrdersAsTimeout(self, vendorId):
4564 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4565 
    args = markOrdersAsTimeout_args()
4566 
    args.vendorId = vendorId
4567 
    args.write(self._oprot)
4568 
    self._oprot.writeMessageEnd()
4569 
    self._oprot.trans.flush()
4570 
 
4571 
  def recv_markOrdersAsTimeout(self, ):
4572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4573 
    if mtype == TMessageType.EXCEPTION:
4574 
      x = TApplicationException()
4575 
      x.read(self._iprot)
4576 
      self._iprot.readMessageEnd()
4577 
      raise x
4578 
    result = markOrdersAsTimeout_result()
4579 
    result.read(self._iprot)
4580 
    self._iprot.readMessageEnd()
4581 
    if result.success is not None:
4582 
      return result.success
4583 
    if result.ex is not None:
4584 
      raise result.ex
4585 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4586 
 
4662 rajveer 4587 
  def markOrderAsLostInTransit(self, orderId):
4588 
    """
4589 
    Mark order as LOST_IN_TRANSIT
4590 
 
4591 
    Parameters:
4592 
     - orderId
4593 
    """
4594 
    self.send_markOrderAsLostInTransit(orderId)
4595 
    return self.recv_markOrderAsLostInTransit()
4596 
 
4597 
  def send_markOrderAsLostInTransit(self, orderId):
4598 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4599 
    args = markOrderAsLostInTransit_args()
4600 
    args.orderId = orderId
4601 
    args.write(self._oprot)
4602 
    self._oprot.writeMessageEnd()
4603 
    self._oprot.trans.flush()
4604 
 
4605 
  def recv_markOrderAsLostInTransit(self, ):
4606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4607 
    if mtype == TMessageType.EXCEPTION:
4608 
      x = TApplicationException()
4609 
      x.read(self._iprot)
4610 
      self._iprot.readMessageEnd()
4611 
      raise x
4612 
    result = markOrderAsLostInTransit_result()
4613 
    result.read(self._iprot)
4614 
    self._iprot.readMessageEnd()
4615 
    if result.success is not None:
4616 
      return result.success
4617 
    if result.ex is not None:
4618 
      raise result.ex
4619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4620 
 
4386 anupam.sin 4621 
  def getOrderForAwb(self, awb):
4622 
    """
4623 
    Returns the order corresponding to an AWB number
4369 rajveer 4624 
 
4386 anupam.sin 4625 
    Parameters:
4626 
     - awb
4627 
    """
4628 
    self.send_getOrderForAwb(awb)
4629 
    return self.recv_getOrderForAwb()
4630 
 
4631 
  def send_getOrderForAwb(self, awb):
4632 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4633 
    args = getOrderForAwb_args()
4634 
    args.awb = awb
4635 
    args.write(self._oprot)
4636 
    self._oprot.writeMessageEnd()
4637 
    self._oprot.trans.flush()
4638 
 
4639 
  def recv_getOrderForAwb(self, ):
4640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4641 
    if mtype == TMessageType.EXCEPTION:
4642 
      x = TApplicationException()
4643 
      x.read(self._iprot)
4644 
      self._iprot.readMessageEnd()
4645 
      raise x
4646 
    result = getOrderForAwb_result()
4647 
    result.read(self._iprot)
4648 
    self._iprot.readMessageEnd()
4649 
    if result.success is not None:
4650 
      return result.success
4651 
    if result.ex is not None:
4652 
      raise result.ex
4653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4654 
 
4910 phani.kuma 4655 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4656 
    """
4910 phani.kuma 4657 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4658 
 
4506 phani.kuma 4659 
    Parameters:
4660 
     - logistics_provider_id
4910 phani.kuma 4661 
     - order_status_list
4506 phani.kuma 4662 
    """
4910 phani.kuma 4663 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4664 
    return self.recv_getOrdersForProviderForStatus()
4665 
 
4910 phani.kuma 4666 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4667 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4668 
    args = getOrdersForProviderForStatus_args()
4669 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4670 
    args.order_status_list = order_status_list
4506 phani.kuma 4671 
    args.write(self._oprot)
4672 
    self._oprot.writeMessageEnd()
4673 
    self._oprot.trans.flush()
4674 
 
4675 
  def recv_getOrdersForProviderForStatus(self, ):
4676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4677 
    if mtype == TMessageType.EXCEPTION:
4678 
      x = TApplicationException()
4679 
      x.read(self._iprot)
4680 
      self._iprot.readMessageEnd()
4681 
      raise x
4682 
    result = getOrdersForProviderForStatus_result()
4683 
    result.read(self._iprot)
4684 
    self._iprot.readMessageEnd()
4685 
    if result.success is not None:
4686 
      return result.success
4687 
    if result.ex is not None:
4688 
      raise result.ex
4689 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4690 
 
4600 varun.gupt 4691 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4692 
    """
4693 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4694 
 
4600 varun.gupt 4695 
    Parameters:
4696 
     - vendorId
4697 
     - billingDateFrom
4698 
     - billingDateTo
4699 
    """
4700 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4701 
    return self.recv_getBilledOrdersForVendor()
4702 
 
4703 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4704 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4705 
    args = getBilledOrdersForVendor_args()
4706 
    args.vendorId = vendorId
4707 
    args.billingDateFrom = billingDateFrom
4708 
    args.billingDateTo = billingDateTo
4709 
    args.write(self._oprot)
4710 
    self._oprot.writeMessageEnd()
4711 
    self._oprot.trans.flush()
4712 
 
4713 
  def recv_getBilledOrdersForVendor(self, ):
4714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4715 
    if mtype == TMessageType.EXCEPTION:
4716 
      x = TApplicationException()
4717 
      x.read(self._iprot)
4718 
      self._iprot.readMessageEnd()
4719 
      raise x
4720 
    result = getBilledOrdersForVendor_result()
4721 
    result.read(self._iprot)
4722 
    self._iprot.readMessageEnd()
4723 
    if result.success is not None:
4724 
      return result.success
4725 
    if result.ex is not None:
4726 
      raise result.ex
4727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4728 
 
4607 rajveer 4729 
  def getSlippedSippingDateOrders(self, ):
4730 
    self.send_getSlippedSippingDateOrders()
4731 
    return self.recv_getSlippedSippingDateOrders()
4732 
 
4733 
  def send_getSlippedSippingDateOrders(self, ):
4734 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4735 
    args = getSlippedSippingDateOrders_args()
4736 
    args.write(self._oprot)
4737 
    self._oprot.writeMessageEnd()
4738 
    self._oprot.trans.flush()
4739 
 
4740 
  def recv_getSlippedSippingDateOrders(self, ):
4741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4742 
    if mtype == TMessageType.EXCEPTION:
4743 
      x = TApplicationException()
4744 
      x.read(self._iprot)
4745 
      self._iprot.readMessageEnd()
4746 
      raise x
4747 
    result = getSlippedSippingDateOrders_result()
4748 
    result.read(self._iprot)
4749 
    self._iprot.readMessageEnd()
4750 
    if result.success is not None:
4751 
      return result.success
4752 
    if result.ex is not None:
4753 
      raise result.ex
4754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4755 
 
4709 rajveer 4756 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4757 
    """
4758 
    Parameters:
4759 
     - cancelDateFrom
4760 
     - cancelDateTo
4761 
    """
4762 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4763 
    return self.recv_getCancelledOrders()
4764 
 
4765 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4766 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4767 
    args = getCancelledOrders_args()
4768 
    args.cancelDateFrom = cancelDateFrom
4769 
    args.cancelDateTo = cancelDateTo
4770 
    args.write(self._oprot)
4771 
    self._oprot.writeMessageEnd()
4772 
    self._oprot.trans.flush()
4773 
 
4774 
  def recv_getCancelledOrders(self, ):
4775 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4776 
    if mtype == TMessageType.EXCEPTION:
4777 
      x = TApplicationException()
4778 
      x.read(self._iprot)
4779 
      self._iprot.readMessageEnd()
4780 
      raise x
4781 
    result = getCancelledOrders_result()
4782 
    result.read(self._iprot)
4783 
    self._iprot.readMessageEnd()
4784 
    if result.success is not None:
4785 
      return result.success
4786 
    if result.ex is not None:
4787 
      raise result.ex
4788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4789 
 
4600 varun.gupt 4790 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4791 
    """
4792 
    Parameters:
4793 
     - mapAWBAndAmount
4794 
    """
4795 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4796 
    self.recv_saveBluedartSettlements()
4797 
 
4798 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4799 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4800 
    args = saveBluedartSettlements_args()
4801 
    args.mapAWBAndAmount = mapAWBAndAmount
4802 
    args.write(self._oprot)
4803 
    self._oprot.writeMessageEnd()
4804 
    self._oprot.trans.flush()
4805 
 
4806 
  def recv_saveBluedartSettlements(self, ):
4807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4808 
    if mtype == TMessageType.EXCEPTION:
4809 
      x = TApplicationException()
4810 
      x.read(self._iprot)
4811 
      self._iprot.readMessageEnd()
4812 
      raise x
4813 
    result = saveBluedartSettlements_result()
4814 
    result.read(self._iprot)
4815 
    self._iprot.readMessageEnd()
4816 
    if result.ex is not None:
4817 
      raise result.ex
4818 
    return
4819 
 
4905 varun.gupt 4820 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4821 
    """
4822 
    Parameters:
4823 
     - settlementDate
4824 
     - paymentGatewayId
4905 varun.gupt 4825 
     - referenceId
4600 varun.gupt 4826 
     - serviceTax
4827 
     - otherCharges
4828 
     - netCollection
4829 
    """
4905 varun.gupt 4830 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4831 
    self.recv_savePaymentSettlements()
4832 
 
4905 varun.gupt 4833 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4834 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4835 
    args = savePaymentSettlements_args()
4836 
    args.settlementDate = settlementDate
4837 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4838 
    args.referenceId = referenceId
4600 varun.gupt 4839 
    args.serviceTax = serviceTax
4840 
    args.otherCharges = otherCharges
4841 
    args.netCollection = netCollection
4842 
    args.write(self._oprot)
4843 
    self._oprot.writeMessageEnd()
4844 
    self._oprot.trans.flush()
4845 
 
4846 
  def recv_savePaymentSettlements(self, ):
4847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4848 
    if mtype == TMessageType.EXCEPTION:
4849 
      x = TApplicationException()
4850 
      x.read(self._iprot)
4851 
      self._iprot.readMessageEnd()
4852 
      raise x
4853 
    result = savePaymentSettlements_result()
4854 
    result.read(self._iprot)
4855 
    self._iprot.readMessageEnd()
4856 
    if result.ex is not None:
4857 
      raise result.ex
4858 
    return
4859 
 
4860 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4861 
    """
4862 
    Parameters:
4863 
     - settlementId
4864 
     - settlementDate
4865 
     - transactionDateFrom
4866 
     - transactionDateTo
4867 
     - amount
4868 
    """
4869 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4870 
    self.recv_saveEBSSettlementSummary()
4871 
 
4872 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4873 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4874 
    args = saveEBSSettlementSummary_args()
4875 
    args.settlementId = settlementId
4876 
    args.settlementDate = settlementDate
4877 
    args.transactionDateFrom = transactionDateFrom
4878 
    args.transactionDateTo = transactionDateTo
4879 
    args.amount = amount
4880 
    args.write(self._oprot)
4881 
    self._oprot.writeMessageEnd()
4882 
    self._oprot.trans.flush()
4883 
 
4884 
  def recv_saveEBSSettlementSummary(self, ):
4885 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4886 
    if mtype == TMessageType.EXCEPTION:
4887 
      x = TApplicationException()
4888 
      x.read(self._iprot)
4889 
      self._iprot.readMessageEnd()
4890 
      raise x
4891 
    result = saveEBSSettlementSummary_result()
4892 
    result.read(self._iprot)
4893 
    self._iprot.readMessageEnd()
4894 
    if result.ex is not None:
4895 
      raise result.ex
4896 
    return
4897 
 
5386 phani.kuma 4898 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 4899 
    """
4900 
    Parameters:
5189 varun.gupt 4901 
     - referenceId
4902 
     - isRefund
4600 varun.gupt 4903 
    """
5386 phani.kuma 4904 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
4905 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 4906 
 
5386 phani.kuma 4907 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
4908 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
4909 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 4910 
    args.referenceId = referenceId
4911 
    args.isRefund = isRefund
4600 varun.gupt 4912 
    args.write(self._oprot)
4913 
    self._oprot.writeMessageEnd()
4914 
    self._oprot.trans.flush()
4915 
 
5386 phani.kuma 4916 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 4917 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4918 
    if mtype == TMessageType.EXCEPTION:
4919 
      x = TApplicationException()
4920 
      x.read(self._iprot)
4921 
      self._iprot.readMessageEnd()
4922 
      raise x
5386 phani.kuma 4923 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 4924 
    result.read(self._iprot)
4925 
    self._iprot.readMessageEnd()
4926 
    if result.success is not None:
4927 
      return result.success
4928 
    if result.ex is not None:
4929 
      raise result.ex
5386 phani.kuma 4930 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 4931 
 
5386 phani.kuma 4932 
  def getSettlementForCod(self, orderId, isRefund):
4933 
    """
4934 
    Parameters:
4935 
     - orderId
4936 
     - isRefund
4937 
    """
4938 
    self.send_getSettlementForCod(orderId, isRefund)
4939 
    return self.recv_getSettlementForCod()
4940 
 
4941 
  def send_getSettlementForCod(self, orderId, isRefund):
4942 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
4943 
    args = getSettlementForCod_args()
4944 
    args.orderId = orderId
4945 
    args.isRefund = isRefund
4946 
    args.write(self._oprot)
4947 
    self._oprot.writeMessageEnd()
4948 
    self._oprot.trans.flush()
4949 
 
4950 
  def recv_getSettlementForCod(self, ):
4951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4952 
    if mtype == TMessageType.EXCEPTION:
4953 
      x = TApplicationException()
4954 
      x.read(self._iprot)
4955 
      self._iprot.readMessageEnd()
4956 
      raise x
4957 
    result = getSettlementForCod_result()
4958 
    result.read(self._iprot)
4959 
    self._iprot.readMessageEnd()
4960 
    if result.success is not None:
4961 
      return result.success
4962 
    if result.ex is not None:
4963 
      raise result.ex
4964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
4965 
 
4600 varun.gupt 4966 
  def getEBSSettlementSummaries(self, ):
4967 
    self.send_getEBSSettlementSummaries()
4968 
    return self.recv_getEBSSettlementSummaries()
4969 
 
4970 
  def send_getEBSSettlementSummaries(self, ):
4971 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4972 
    args = getEBSSettlementSummaries_args()
4973 
    args.write(self._oprot)
4974 
    self._oprot.writeMessageEnd()
4975 
    self._oprot.trans.flush()
4976 
 
4977 
  def recv_getEBSSettlementSummaries(self, ):
4978 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4979 
    if mtype == TMessageType.EXCEPTION:
4980 
      x = TApplicationException()
4981 
      x.read(self._iprot)
4982 
      self._iprot.readMessageEnd()
4983 
      raise x
4984 
    result = getEBSSettlementSummaries_result()
4985 
    result.read(self._iprot)
4986 
    self._iprot.readMessageEnd()
4987 
    if result.success is not None:
4988 
      return result.success
4989 
    if result.ex is not None:
4990 
      raise result.ex
4991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4992 
 
4993 
  def markEBSSettlementUploaded(self, settlementId):
4994 
    """
4995 
    Parameters:
4996 
     - settlementId
4997 
    """
4998 
    self.send_markEBSSettlementUploaded(settlementId)
4999 
    self.recv_markEBSSettlementUploaded()
5000 
 
5001 
  def send_markEBSSettlementUploaded(self, settlementId):
5002 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5003 
    args = markEBSSettlementUploaded_args()
5004 
    args.settlementId = settlementId
5005 
    args.write(self._oprot)
5006 
    self._oprot.writeMessageEnd()
5007 
    self._oprot.trans.flush()
5008 
 
5009 
  def recv_markEBSSettlementUploaded(self, ):
5010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5011 
    if mtype == TMessageType.EXCEPTION:
5012 
      x = TApplicationException()
5013 
      x.read(self._iprot)
5014 
      self._iprot.readMessageEnd()
5015 
      raise x
5016 
    result = markEBSSettlementUploaded_result()
5017 
    result.read(self._iprot)
5018 
    self._iprot.readMessageEnd()
5019 
    if result.ex is not None:
5020 
      raise result.ex
5021 
    return
5022 
 
5023 
  def getEBSSettlementDate(self, settlementId):
5024 
    """
5025 
    Parameters:
5026 
     - settlementId
5027 
    """
5028 
    self.send_getEBSSettlementDate(settlementId)
5029 
    return self.recv_getEBSSettlementDate()
5030 
 
5031 
  def send_getEBSSettlementDate(self, settlementId):
5032 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5033 
    args = getEBSSettlementDate_args()
5034 
    args.settlementId = settlementId
5035 
    args.write(self._oprot)
5036 
    self._oprot.writeMessageEnd()
5037 
    self._oprot.trans.flush()
5038 
 
5039 
  def recv_getEBSSettlementDate(self, ):
5040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5041 
    if mtype == TMessageType.EXCEPTION:
5042 
      x = TApplicationException()
5043 
      x.read(self._iprot)
5044 
      self._iprot.readMessageEnd()
5045 
      raise x
5046 
    result = getEBSSettlementDate_result()
5047 
    result.read(self._iprot)
5048 
    self._iprot.readMessageEnd()
5049 
    if result.success is not None:
5050 
      return result.success
5051 
    if result.ex is not None:
5052 
      raise result.ex
5053 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5054 
 
4715 varun.gupt 5055 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5056 
    """
5057 
    Parameters:
5058 
     - settlementDateFrom
5059 
     - settlementDateTo
5060 
     - isRefund
5061 
    """
5062 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5063 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5064 
 
4715 varun.gupt 5065 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5066 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5067 
    args = getSettlementsByDate_args()
5068 
    args.settlementDateFrom = settlementDateFrom
5069 
    args.settlementDateTo = settlementDateTo
5070 
    args.isRefund = isRefund
5071 
    args.write(self._oprot)
5072 
    self._oprot.writeMessageEnd()
5073 
    self._oprot.trans.flush()
5074 
 
5075 
  def recv_getSettlementsByDate(self, ):
5076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5077 
    if mtype == TMessageType.EXCEPTION:
5078 
      x = TApplicationException()
5079 
      x.read(self._iprot)
5080 
      self._iprot.readMessageEnd()
5081 
      raise x
5082 
    result = getSettlementsByDate_result()
5083 
    result.read(self._iprot)
5084 
    self._iprot.readMessageEnd()
5085 
    if result.success is not None:
5086 
      return result.success
5087 
    if result.ex is not None:
5088 
      raise result.ex
5089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5090 
 
5091 
  def getReshippedOrderIds(self, orderIds):
5092 
    """
5093 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5094 
 
5095 
    Parameters:
5096 
     - orderIds
5097 
    """
5098 
    self.send_getReshippedOrderIds(orderIds)
5099 
    return self.recv_getReshippedOrderIds()
5100 
 
5101 
  def send_getReshippedOrderIds(self, orderIds):
5102 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5103 
    args = getReshippedOrderIds_args()
5104 
    args.orderIds = orderIds
5105 
    args.write(self._oprot)
5106 
    self._oprot.writeMessageEnd()
5107 
    self._oprot.trans.flush()
5108 
 
5109 
  def recv_getReshippedOrderIds(self, ):
5110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5111 
    if mtype == TMessageType.EXCEPTION:
5112 
      x = TApplicationException()
5113 
      x.read(self._iprot)
5114 
      self._iprot.readMessageEnd()
5115 
      raise x
5116 
    result = getReshippedOrderIds_result()
5117 
    result.read(self._iprot)
5118 
    self._iprot.readMessageEnd()
5119 
    if result.success is not None:
5120 
      return result.success
5121 
    if result.ex is not None:
5122 
      raise result.ex
5123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5124 
 
5481 phani.kuma 5125 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5126 
    """
5127 
    Parameters:
5128 
     - vendorId
5481 phani.kuma 5129 
     - onlyVendorNotPaid
5130 
     - billingDateFrom
5131 
     - billingDateTo
4875 varun.gupt 5132 
    """
5481 phani.kuma 5133 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5134 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5135 
 
5481 phani.kuma 5136 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5137 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5138 
    args = getBilledOrders_args()
4875 varun.gupt 5139 
    args.vendorId = vendorId
5481 phani.kuma 5140 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5141 
    args.billingDateFrom = billingDateFrom
5142 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5143 
    args.write(self._oprot)
5144 
    self._oprot.writeMessageEnd()
5145 
    self._oprot.trans.flush()
5146 
 
5481 phani.kuma 5147 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5148 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5149 
    if mtype == TMessageType.EXCEPTION:
5150 
      x = TApplicationException()
5151 
      x.read(self._iprot)
5152 
      self._iprot.readMessageEnd()
5153 
      raise x
5481 phani.kuma 5154 
    result = getBilledOrders_result()
4875 varun.gupt 5155 
    result.read(self._iprot)
5156 
    self._iprot.readMessageEnd()
5157 
    if result.success is not None:
5158 
      return result.success
5159 
    if result.ex is not None:
5160 
      raise result.ex
5481 phani.kuma 5161 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5162 
 
5031 varun.gupt 5163 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5164 
    """
5165 
    Parameters:
5166 
     - startDate
5167 
     - endDate
5168 
    """
5169 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5170 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5171 
 
5031 varun.gupt 5172 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5173 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5174 
    args = getStatusDistributionOfOrders_args()
5175 
    args.startDate = startDate
5176 
    args.endDate = endDate
5177 
    args.write(self._oprot)
5178 
    self._oprot.writeMessageEnd()
5179 
    self._oprot.trans.flush()
5180 
 
5181 
  def recv_getStatusDistributionOfOrders(self, ):
5182 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5183 
    if mtype == TMessageType.EXCEPTION:
5184 
      x = TApplicationException()
5185 
      x.read(self._iprot)
5186 
      self._iprot.readMessageEnd()
5187 
      raise x
5188 
    result = getStatusDistributionOfOrders_result()
5189 
    result.read(self._iprot)
5190 
    self._iprot.readMessageEnd()
5191 
    if result.success is not None:
5192 
      return result.success
5193 
    if result.ex is not None:
5194 
      raise result.ex
5195 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5196 
 
5067 varun.gupt 5197 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5198 
    """
5199 
    Parameters:
5200 
     - status
5201 
     - startDatetime
5202 
     - endDatetime
5203 
    """
5204 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5205 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5206 
 
5067 varun.gupt 5207 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5208 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5209 
    args = getOrderIdsForStatus_args()
5210 
    args.status = status
5211 
    args.startDatetime = startDatetime
5212 
    args.endDatetime = endDatetime
5213 
    args.write(self._oprot)
5214 
    self._oprot.writeMessageEnd()
5215 
    self._oprot.trans.flush()
5216 
 
5217 
  def recv_getOrderIdsForStatus(self, ):
5218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5219 
    if mtype == TMessageType.EXCEPTION:
5220 
      x = TApplicationException()
5221 
      x.read(self._iprot)
5222 
      self._iprot.readMessageEnd()
5223 
      raise x
5224 
    result = getOrderIdsForStatus_result()
5225 
    result.read(self._iprot)
5226 
    self._iprot.readMessageEnd()
5227 
    if result.success is not None:
5228 
      return result.success
5229 
    if result.ex is not None:
5230 
      raise result.ex
5231 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5232 
 
5348 anupam.sin 5233 
  def updateCODAgent(self, agent, orderId):
5234 
    """
5235 
    Updates the agent who handled the COD verification call
5236 
 
5237 
    Parameters:
5238 
     - agent
5239 
     - orderId
5240 
    """
5241 
    self.send_updateCODAgent(agent, orderId)
5242 
    self.recv_updateCODAgent()
5243 
 
5244 
  def send_updateCODAgent(self, agent, orderId):
5245 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5246 
    args = updateCODAgent_args()
5247 
    args.agent = agent
5248 
    args.orderId = orderId
5249 
    args.write(self._oprot)
5250 
    self._oprot.writeMessageEnd()
5251 
    self._oprot.trans.flush()
5252 
 
5253 
  def recv_updateCODAgent(self, ):
5254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5255 
    if mtype == TMessageType.EXCEPTION:
5256 
      x = TApplicationException()
5257 
      x.read(self._iprot)
5258 
      self._iprot.readMessageEnd()
5259 
      raise x
5260 
    result = updateCODAgent_result()
5261 
    result.read(self._iprot)
5262 
    self._iprot.readMessageEnd()
5263 
    if result.ex is not None:
5264 
      raise result.ex
5265 
    return
5266 
 
5099 varun.gupt 5267 
  def updateOrderAsPaidToVendor(self, orderId):
5268 
    """
5269 
    Parameters:
5270 
     - orderId
5271 
    """
5272 
    self.send_updateOrderAsPaidToVendor(orderId)
5273 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5274 
 
5099 varun.gupt 5275 
  def send_updateOrderAsPaidToVendor(self, orderId):
5276 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5277 
    args = updateOrderAsPaidToVendor_args()
5278 
    args.orderId = orderId
5279 
    args.write(self._oprot)
5280 
    self._oprot.writeMessageEnd()
5281 
    self._oprot.trans.flush()
5282 
 
5283 
  def recv_updateOrderAsPaidToVendor(self, ):
5284 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5285 
    if mtype == TMessageType.EXCEPTION:
5286 
      x = TApplicationException()
5287 
      x.read(self._iprot)
5288 
      self._iprot.readMessageEnd()
5289 
      raise x
5290 
    result = updateOrderAsPaidToVendor_result()
5291 
    result.read(self._iprot)
5292 
    self._iprot.readMessageEnd()
5293 
    if result.ex is not None:
5294 
      raise result.ex
5295 
    return
5296 
 
5386 phani.kuma 5297 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5298 
    """
5299 
    Parameters:
5300 
     - orderId
5301 
    """
5302 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5303 
    self.recv_updateOrderOnlyAsPaidToVendor()
5304 
 
5305 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5306 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5307 
    args = updateOrderOnlyAsPaidToVendor_args()
5308 
    args.orderId = orderId
5309 
    args.write(self._oprot)
5310 
    self._oprot.writeMessageEnd()
5311 
    self._oprot.trans.flush()
5312 
 
5313 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5314 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5315 
    if mtype == TMessageType.EXCEPTION:
5316 
      x = TApplicationException()
5317 
      x.read(self._iprot)
5318 
      self._iprot.readMessageEnd()
5319 
      raise x
5320 
    result = updateOrderOnlyAsPaidToVendor_result()
5321 
    result.read(self._iprot)
5322 
    self._iprot.readMessageEnd()
5323 
    if result.ex is not None:
5324 
      raise result.ex
5325 
    return
5326 
 
5208 varun.gupt 5327 
  def getRefundedOrdersMarkedPaid(self, ):
5328 
    self.send_getRefundedOrdersMarkedPaid()
5329 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5330 
 
5208 varun.gupt 5331 
  def send_getRefundedOrdersMarkedPaid(self, ):
5332 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5333 
    args = getRefundedOrdersMarkedPaid_args()
5334 
    args.write(self._oprot)
5335 
    self._oprot.writeMessageEnd()
5336 
    self._oprot.trans.flush()
5337 
 
5338 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5340 
    if mtype == TMessageType.EXCEPTION:
5341 
      x = TApplicationException()
5342 
      x.read(self._iprot)
5343 
      self._iprot.readMessageEnd()
5344 
      raise x
5345 
    result = getRefundedOrdersMarkedPaid_result()
5346 
    result.read(self._iprot)
5347 
    self._iprot.readMessageEnd()
5348 
    if result.success is not None:
5349 
      return result.success
5350 
    if result.ex is not None:
5351 
      raise result.ex
5352 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5353 
 
5447 anupam.sin 5354 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5355 
    """
5356 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5357 
 
5447 anupam.sin 5358 
 
5359 
    Parameters:
5360 
     - minOrderId
5361 
     - maxOrderId
5362 
    """
5363 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5364 
    return self.recv_getAllVerificationAgents()
5365 
 
5366 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5367 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5368 
    args = getAllVerificationAgents_args()
5369 
    args.minOrderId = minOrderId
5370 
    args.maxOrderId = maxOrderId
5371 
    args.write(self._oprot)
5372 
    self._oprot.writeMessageEnd()
5373 
    self._oprot.trans.flush()
5374 
 
5375 
  def recv_getAllVerificationAgents(self, ):
5376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5377 
    if mtype == TMessageType.EXCEPTION:
5378 
      x = TApplicationException()
5379 
      x.read(self._iprot)
5380 
      self._iprot.readMessageEnd()
5381 
      raise x
5382 
    result = getAllVerificationAgents_result()
5383 
    result.read(self._iprot)
5384 
    self._iprot.readMessageEnd()
5385 
    if result.success is not None:
5386 
      return result.success
5387 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5388 
 
5527 anupam.sin 5389 
  def getAllAttributesForOrderId(self, orderId):
5390 
    """
5391 
    gets all attributes for a given orderId
5447 anupam.sin 5392 
 
5527 anupam.sin 5393 
    Parameters:
5394 
     - orderId
5395 
    """
5396 
    self.send_getAllAttributesForOrderId(orderId)
5397 
    return self.recv_getAllAttributesForOrderId()
5398 
 
5399 
  def send_getAllAttributesForOrderId(self, orderId):
5400 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5401 
    args = getAllAttributesForOrderId_args()
5402 
    args.orderId = orderId
5403 
    args.write(self._oprot)
5404 
    self._oprot.writeMessageEnd()
5405 
    self._oprot.trans.flush()
5406 
 
5407 
  def recv_getAllAttributesForOrderId(self, ):
5408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5409 
    if mtype == TMessageType.EXCEPTION:
5410 
      x = TApplicationException()
5411 
      x.read(self._iprot)
5412 
      self._iprot.readMessageEnd()
5413 
      raise x
5414 
    result = getAllAttributesForOrderId_result()
5415 
    result.read(self._iprot)
5416 
    self._iprot.readMessageEnd()
5417 
    if result.success is not None:
5418 
      return result.success
5419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5420 
 
5676 rajveer 5421 
  def setOrderAttributes(self, orderId, attributes):
5422 
    """
5423 
    sets attributes for an order
5424 
 
5425 
    Parameters:
5426 
     - orderId
5427 
     - attributes
5428 
    """
5429 
    self.send_setOrderAttributes(orderId, attributes)
5430 
    self.recv_setOrderAttributes()
5431 
 
5432 
  def send_setOrderAttributes(self, orderId, attributes):
5433 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5434 
    args = setOrderAttributes_args()
5435 
    args.orderId = orderId
5436 
    args.attributes = attributes
5437 
    args.write(self._oprot)
5438 
    self._oprot.writeMessageEnd()
5439 
    self._oprot.trans.flush()
5440 
 
5441 
  def recv_setOrderAttributes(self, ):
5442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5443 
    if mtype == TMessageType.EXCEPTION:
5444 
      x = TApplicationException()
5445 
      x.read(self._iprot)
5446 
      self._iprot.readMessageEnd()
5447 
      raise x
5448 
    result = setOrderAttributes_result()
5449 
    result.read(self._iprot)
5450 
    self._iprot.readMessageEnd()
5451 
    return
5452 
 
5527 anupam.sin 5453 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5454 
    """
5455 
    sets attributes for all orders in a transaction
5456 
 
5457 
    Parameters:
5458 
     - transactionId
5459 
     - attribute
5460 
    """
5461 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5462 
    self.recv_setOrderAttributeForTransaction()
5463 
 
5464 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5465 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5466 
    args = setOrderAttributeForTransaction_args()
5467 
    args.transactionId = transactionId
5468 
    args.attribute = attribute
5469 
    args.write(self._oprot)
5470 
    self._oprot.writeMessageEnd()
5471 
    self._oprot.trans.flush()
5472 
 
5473 
  def recv_setOrderAttributeForTransaction(self, ):
5474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5475 
    if mtype == TMessageType.EXCEPTION:
5476 
      x = TApplicationException()
5477 
      x.read(self._iprot)
5478 
      self._iprot.readMessageEnd()
5479 
      raise x
5480 
    result = setOrderAttributeForTransaction_result()
5481 
    result.read(self._iprot)
5482 
    self._iprot.readMessageEnd()
5483 
    return
5484 
 
5553 rajveer 5485 
  def getReceivePendingOrders(self, storeId):
5486 
    """
5487 
    Parameters:
5488 
     - storeId
5489 
    """
5490 
    self.send_getReceivePendingOrders(storeId)
5491 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5492 
 
5553 rajveer 5493 
  def send_getReceivePendingOrders(self, storeId):
5494 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5495 
    args = getReceivePendingOrders_args()
5496 
    args.storeId = storeId
5497 
    args.write(self._oprot)
5498 
    self._oprot.writeMessageEnd()
5499 
    self._oprot.trans.flush()
5500 
 
5501 
  def recv_getReceivePendingOrders(self, ):
5502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5503 
    if mtype == TMessageType.EXCEPTION:
5504 
      x = TApplicationException()
5505 
      x.read(self._iprot)
5506 
      self._iprot.readMessageEnd()
5507 
      raise x
5508 
    result = getReceivePendingOrders_result()
5509 
    result.read(self._iprot)
5510 
    self._iprot.readMessageEnd()
5511 
    if result.success is not None:
5512 
      return result.success
5513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5514 
 
5515 
  def getReceivedAtStoreOrders(self, storeId):
5516 
    """
5517 
    Parameters:
5518 
     - storeId
5519 
    """
5520 
    self.send_getReceivedAtStoreOrders(storeId)
5521 
    return self.recv_getReceivedAtStoreOrders()
5522 
 
5523 
  def send_getReceivedAtStoreOrders(self, storeId):
5524 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5525 
    args = getReceivedAtStoreOrders_args()
5526 
    args.storeId = storeId
5527 
    args.write(self._oprot)
5528 
    self._oprot.writeMessageEnd()
5529 
    self._oprot.trans.flush()
5530 
 
5531 
  def recv_getReceivedAtStoreOrders(self, ):
5532 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5533 
    if mtype == TMessageType.EXCEPTION:
5534 
      x = TApplicationException()
5535 
      x.read(self._iprot)
5536 
      self._iprot.readMessageEnd()
5537 
      raise x
5538 
    result = getReceivedAtStoreOrders_result()
5539 
    result.read(self._iprot)
5540 
    self._iprot.readMessageEnd()
5541 
    if result.success is not None:
5542 
      return result.success
5543 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5544 
 
5713 rajveer 5545 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5546 
    """
5547 
    Parameters:
5548 
     - storeId
5549 
     - fromDate
5550 
     - toDate
5551 
     - onlyCod
5552 
    """
5553 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5554 
    return self.recv_getOrdersCollectionAtStore()
5555 
 
5556 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5557 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5558 
    args = getOrdersCollectionAtStore_args()
5559 
    args.storeId = storeId
5560 
    args.fromDate = fromDate
5561 
    args.toDate = toDate
5562 
    args.onlyCod = onlyCod
5563 
    args.write(self._oprot)
5564 
    self._oprot.writeMessageEnd()
5565 
    self._oprot.trans.flush()
5566 
 
5567 
  def recv_getOrdersCollectionAtStore(self, ):
5568 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5569 
    if mtype == TMessageType.EXCEPTION:
5570 
      x = TApplicationException()
5571 
      x.read(self._iprot)
5572 
      self._iprot.readMessageEnd()
5573 
      raise x
5574 
    result = getOrdersCollectionAtStore_result()
5575 
    result.read(self._iprot)
5576 
    self._iprot.readMessageEnd()
5577 
    if result.success is not None:
5578 
      return result.success
5579 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5580 
 
5833 rajveer 5581 
  def getOrderAttributeValue(self, orderId, attributeName):
5582 
    """
5583 
    Parameters:
5584 
     - orderId
5585 
     - attributeName
5586 
    """
5587 
    self.send_getOrderAttributeValue(orderId, attributeName)
5588 
    return self.recv_getOrderAttributeValue()
5589 
 
5590 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5591 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5592 
    args = getOrderAttributeValue_args()
5593 
    args.orderId = orderId
5594 
    args.attributeName = attributeName
5595 
    args.write(self._oprot)
5596 
    self._oprot.writeMessageEnd()
5597 
    self._oprot.trans.flush()
5598 
 
5599 
  def recv_getOrderAttributeValue(self, ):
5600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5601 
    if mtype == TMessageType.EXCEPTION:
5602 
      x = TApplicationException()
5603 
      x.read(self._iprot)
5604 
      self._iprot.readMessageEnd()
5605 
      raise x
5606 
    result = getOrderAttributeValue_result()
5607 
    result.read(self._iprot)
5608 
    self._iprot.readMessageEnd()
5609 
    if result.success is not None:
5610 
      return result.success
5611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5612 
 
5593 mandeep.dh 5613 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5614 
    """
5615 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5616 
    invoked while scanning IN of items.
5553 rajveer 5617 
 
5593 mandeep.dh 5618 
    Parameters:
5619 
     - itemId
5620 
     - quantity
5621 
     - fulfilmentWarehouseId
5622 
     - billingWarehouseId
5623 
    """
5624 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5625 
    self.recv_acceptOrderForItem()
5626 
 
5627 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5628 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5629 
    args = acceptOrderForItem_args()
5630 
    args.itemId = itemId
5631 
    args.quantity = quantity
5632 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5633 
    args.billingWarehouseId = billingWarehouseId
5634 
    args.write(self._oprot)
5635 
    self._oprot.writeMessageEnd()
5636 
    self._oprot.trans.flush()
5637 
 
5638 
  def recv_acceptOrderForItem(self, ):
5639 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5640 
    if mtype == TMessageType.EXCEPTION:
5641 
      x = TApplicationException()
5642 
      x.read(self._iprot)
5643 
      self._iprot.readMessageEnd()
5644 
      raise x
5645 
    result = acceptOrderForItem_result()
5646 
    result.read(self._iprot)
5647 
    self._iprot.readMessageEnd()
5648 
    return
5649 
 
5650 
 
3376 rajveer 5651 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 5652 
  def __init__(self, handler):
3376 rajveer 5653 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 5654 
    self._processMap["createTransaction"] = Processor.process_createTransaction
5655 
    self._processMap["getTransaction"] = Processor.process_getTransaction
5656 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 5657 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 5658 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
5659 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 5660 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 5661 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 5662 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
5663 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 5664 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 5665 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 5666 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
5667 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 5668 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
5669 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
5670 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
5671 
    self._processMap["createOrder"] = Processor.process_createOrder
5672 
    self._processMap["getOrder"] = Processor.process_getOrder
5673 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 5674 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 5675 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 5676 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5677 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5678 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5679 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5680 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5681 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5682 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5683 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5684 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5685 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5686 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5687 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5688 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5689 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5690 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 5691 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 5692 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5693 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5694 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5695 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5696 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5697 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5698 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5699 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5700 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5701 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5702 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5703 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5704 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5705 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5706 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 5707 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 5708 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5709 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5710 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5711 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5712 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5713 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5714 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5715 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5716 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5717 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5718 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5719 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5720 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5721 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5722 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5723 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 5724 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 5725 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5726 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5727 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5728 
    self._processMap["changeItem"] = Processor.process_changeItem
5729 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5730 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5731 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5732 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5733 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5734 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5735 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5736 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5737 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5738 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5739 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5740 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5741 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5742 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5743 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5744 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5745 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5746 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5747 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5748 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5749 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5750 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5751 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5752 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5753 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5754 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5755 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 5756 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
5757 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 5758 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5759 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5760 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5761 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5762 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 5763 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 5764 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5765 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 5766 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 5767 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 5768 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 5769 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 5770 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 5771 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 5772 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 5773 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 5774 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
5775 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 5776 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 5777 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
5593 mandeep.dh 5778 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
94 ashish 5779 
 
5780 
  def process(self, iprot, oprot):
5781 
    (name, type, seqid) = iprot.readMessageBegin()
5782 
    if name not in self._processMap:
5783 
      iprot.skip(TType.STRUCT)
5784 
      iprot.readMessageEnd()
5785 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5786 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5787 
      x.write(oprot)
5788 
      oprot.writeMessageEnd()
5789 
      oprot.trans.flush()
5790 
      return
5791 
    else:
5792 
      self._processMap[name](self, seqid, iprot, oprot)
5793 
    return True
5794 
 
5795 
  def process_createTransaction(self, seqid, iprot, oprot):
5796 
    args = createTransaction_args()
5797 
    args.read(iprot)
5798 
    iprot.readMessageEnd()
5799 
    result = createTransaction_result()
5800 
    try:
132 ashish 5801 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5802 
    except TransactionServiceException, ex:
5803 
      result.ex = ex
5804 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5805 
    result.write(oprot)
5806 
    oprot.writeMessageEnd()
5807 
    oprot.trans.flush()
5808 
 
5809 
  def process_getTransaction(self, seqid, iprot, oprot):
5810 
    args = getTransaction_args()
5811 
    args.read(iprot)
5812 
    iprot.readMessageEnd()
5813 
    result = getTransaction_result()
5814 
    try:
5815 
      result.success = self._handler.getTransaction(args.id)
5816 
    except TransactionServiceException, ex:
5817 
      result.ex = ex
5818 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5819 
    result.write(oprot)
5820 
    oprot.writeMessageEnd()
5821 
    oprot.trans.flush()
5822 
 
5823 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5824 
    args = getTransactionsForCustomer_args()
5825 
    args.read(iprot)
5826 
    iprot.readMessageEnd()
5827 
    result = getTransactionsForCustomer_result()
5828 
    try:
5829 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5830 
    except TransactionServiceException, ex:
5831 
      result.ex = ex
5832 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5833 
    result.write(oprot)
5834 
    oprot.writeMessageEnd()
5835 
    oprot.trans.flush()
5836 
 
132 ashish 5837 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5838 
    args = getTransactionsForShoppingCartId_args()
5839 
    args.read(iprot)
5840 
    iprot.readMessageEnd()
5841 
    result = getTransactionsForShoppingCartId_result()
5842 
    try:
5843 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5844 
    except TransactionServiceException, ex:
5845 
      result.ex = ex
5846 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5847 
    result.write(oprot)
5848 
    oprot.writeMessageEnd()
5849 
    oprot.trans.flush()
5850 
 
94 ashish 5851 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5852 
    args = getTransactionStatus_args()
5853 
    args.read(iprot)
5854 
    iprot.readMessageEnd()
5855 
    result = getTransactionStatus_result()
5856 
    try:
5857 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5858 
    except TransactionServiceException, ex:
5859 
      result.ex = ex
5860 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5861 
    result.write(oprot)
5862 
    oprot.writeMessageEnd()
5863 
    oprot.trans.flush()
5864 
 
5865 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5866 
    args = changeTransactionStatus_args()
5867 
    args.read(iprot)
5868 
    iprot.readMessageEnd()
5869 
    result = changeTransactionStatus_result()
5870 
    try:
5527 anupam.sin 5871 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 5872 
    except TransactionServiceException, ex:
5873 
      result.ex = ex
5874 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5875 
    result.write(oprot)
5876 
    oprot.writeMessageEnd()
5877 
    oprot.trans.flush()
5878 
 
1398 varun.gupt 5879 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5880 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5881 
    args.read(iprot)
5882 
    iprot.readMessageEnd()
1398 varun.gupt 5883 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5884 
    try:
1398 varun.gupt 5885 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5886 
    except TransactionServiceException, ex:
5887 
      result.ex = ex
1398 varun.gupt 5888 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5889 
    result.write(oprot)
5890 
    oprot.writeMessageEnd()
5891 
    oprot.trans.flush()
5892 
 
483 rajveer 5893 
  def process_getAllOrders(self, seqid, iprot, oprot):
5894 
    args = getAllOrders_args()
94 ashish 5895 
    args.read(iprot)
5896 
    iprot.readMessageEnd()
483 rajveer 5897 
    result = getAllOrders_result()
94 ashish 5898 
    try:
4801 anupam.sin 5899 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5900 
    except TransactionServiceException, ex:
5901 
      result.ex = ex
483 rajveer 5902 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5903 
    result.write(oprot)
5904 
    oprot.writeMessageEnd()
5905 
    oprot.trans.flush()
5906 
 
4133 chandransh 5907 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5908 
    args = getOrdersInBatch_args()
5909 
    args.read(iprot)
5910 
    iprot.readMessageEnd()
5911 
    result = getOrdersInBatch_result()
5912 
    try:
5913 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5914 
    except TransactionServiceException, ex:
5915 
      result.ex = ex
5916 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5917 
    result.write(oprot)
5918 
    oprot.writeMessageEnd()
5919 
    oprot.trans.flush()
5920 
 
5921 
  def process_getOrderCount(self, seqid, iprot, oprot):
5922 
    args = getOrderCount_args()
5923 
    args.read(iprot)
5924 
    iprot.readMessageEnd()
5925 
    result = getOrderCount_result()
5926 
    try:
5927 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5928 
    except TransactionServiceException, ex:
5929 
      result.ex = ex
5930 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5931 
    result.write(oprot)
5932 
    oprot.writeMessageEnd()
5933 
    oprot.trans.flush()
5934 
 
999 varun.gupt 5935 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5936 
    args = getOrdersByBillingDate_args()
5937 
    args.read(iprot)
5938 
    iprot.readMessageEnd()
5939 
    result = getOrdersByBillingDate_result()
5940 
    try:
5941 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5942 
    except TransactionServiceException, ex:
5943 
      result.ex = ex
5944 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5945 
    result.write(oprot)
5946 
    oprot.writeMessageEnd()
5947 
    oprot.trans.flush()
5948 
 
3427 chandransh 5949 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5950 
    args = getOrdersByShippingDate_args()
5951 
    args.read(iprot)
5952 
    iprot.readMessageEnd()
5953 
    result = getOrdersByShippingDate_result()
5954 
    try:
3451 chandransh 5955 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5956 
    except TransactionServiceException, ex:
5957 
      result.ex = ex
5958 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5959 
    result.write(oprot)
5960 
    oprot.writeMessageEnd()
5961 
    oprot.trans.flush()
5962 
 
1382 varun.gupt 5963 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5964 
    args = getReturnableOrdersForCustomer_args()
5965 
    args.read(iprot)
5966 
    iprot.readMessageEnd()
5967 
    result = getReturnableOrdersForCustomer_result()
5968 
    try:
5969 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5970 
    except TransactionServiceException, ex:
5971 
      result.ex = ex
5972 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5973 
    result.write(oprot)
5974 
    oprot.writeMessageEnd()
5975 
    oprot.trans.flush()
5976 
 
5977 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5978 
    args = getCancellableOrdersForCustomer_args()
5979 
    args.read(iprot)
5980 
    iprot.readMessageEnd()
5981 
    result = getCancellableOrdersForCustomer_result()
5982 
    try:
5983 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5984 
    except TransactionServiceException, ex:
5985 
      result.ex = ex
5986 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5987 
    result.write(oprot)
5988 
    oprot.writeMessageEnd()
5989 
    oprot.trans.flush()
5990 
 
483 rajveer 5991 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5992 
    args = changeOrderStatus_args()
94 ashish 5993 
    args.read(iprot)
5994 
    iprot.readMessageEnd()
483 rajveer 5995 
    result = changeOrderStatus_result()
94 ashish 5996 
    try:
483 rajveer 5997 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5998 
    except TransactionServiceException, ex:
5999 
      result.ex = ex
483 rajveer 6000 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6001 
    result.write(oprot)
6002 
    oprot.writeMessageEnd()
6003 
    oprot.trans.flush()
6004 
 
483 rajveer 6005 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6006 
    args = getOrdersForTransaction_args()
94 ashish 6007 
    args.read(iprot)
6008 
    iprot.readMessageEnd()
483 rajveer 6009 
    result = getOrdersForTransaction_result()
94 ashish 6010 
    try:
1528 ankur.sing 6011 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6012 
    except TransactionServiceException, ex:
6013 
      result.ex = ex
483 rajveer 6014 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6015 
    result.write(oprot)
6016 
    oprot.writeMessageEnd()
6017 
    oprot.trans.flush()
6018 
 
483 rajveer 6019 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6020 
    args = getOrdersForCustomer_args()
94 ashish 6021 
    args.read(iprot)
6022 
    iprot.readMessageEnd()
483 rajveer 6023 
    result = getOrdersForCustomer_result()
94 ashish 6024 
    try:
3014 chandransh 6025 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6026 
    except TransactionServiceException, ex:
6027 
      result.ex = ex
483 rajveer 6028 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6029 
    result.write(oprot)
6030 
    oprot.writeMessageEnd()
6031 
    oprot.trans.flush()
6032 
 
483 rajveer 6033 
  def process_createOrder(self, seqid, iprot, oprot):
6034 
    args = createOrder_args()
94 ashish 6035 
    args.read(iprot)
6036 
    iprot.readMessageEnd()
483 rajveer 6037 
    result = createOrder_result()
94 ashish 6038 
    try:
483 rajveer 6039 
      result.success = self._handler.createOrder(args.order)
94 ashish 6040 
    except TransactionServiceException, ex:
6041 
      result.ex = ex
483 rajveer 6042 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6043 
    result.write(oprot)
6044 
    oprot.writeMessageEnd()
6045 
    oprot.trans.flush()
6046 
 
483 rajveer 6047 
  def process_getOrder(self, seqid, iprot, oprot):
6048 
    args = getOrder_args()
94 ashish 6049 
    args.read(iprot)
6050 
    iprot.readMessageEnd()
483 rajveer 6051 
    result = getOrder_result()
94 ashish 6052 
    try:
483 rajveer 6053 
      result.success = self._handler.getOrder(args.id)
94 ashish 6054 
    except TransactionServiceException, ex:
6055 
      result.ex = ex
483 rajveer 6056 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6057 
    result.write(oprot)
6058 
    oprot.writeMessageEnd()
6059 
    oprot.trans.flush()
6060 
 
483 rajveer 6061 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6062 
    args = getLineItemsForOrder_args()
94 ashish 6063 
    args.read(iprot)
6064 
    iprot.readMessageEnd()
483 rajveer 6065 
    result = getLineItemsForOrder_result()
94 ashish 6066 
    try:
483 rajveer 6067 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6068 
    except TransactionServiceException, ex:
6069 
      result.ex = ex
483 rajveer 6070 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6071 
    result.write(oprot)
6072 
    oprot.writeMessageEnd()
6073 
    oprot.trans.flush()
6074 
 
4999 phani.kuma 6075 
  def process_getOrderList(self, seqid, iprot, oprot):
6076 
    args = getOrderList_args()
6077 
    args.read(iprot)
6078 
    iprot.readMessageEnd()
6079 
    result = getOrderList_result()
6080 
    result.success = self._handler.getOrderList(args.order_ids)
6081 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6082 
    result.write(oprot)
6083 
    oprot.writeMessageEnd()
6084 
    oprot.trans.flush()
6085 
 
5386 phani.kuma 6086 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6087 
    args = getOrderListForVendor_args()
6088 
    args.read(iprot)
6089 
    iprot.readMessageEnd()
6090 
    result = getOrderListForVendor_result()
6091 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6092 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6093 
    result.write(oprot)
6094 
    oprot.writeMessageEnd()
6095 
    oprot.trans.flush()
6096 
 
1528 ankur.sing 6097 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6098 
    args = getOrderForCustomer_args()
6099 
    args.read(iprot)
6100 
    iprot.readMessageEnd()
6101 
    result = getOrderForCustomer_result()
6102 
    try:
6103 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6104 
    except TransactionServiceException, ex:
6105 
      result.ex = ex
6106 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6107 
    result.write(oprot)
6108 
    oprot.writeMessageEnd()
6109 
    oprot.trans.flush()
6110 
 
3064 chandransh 6111 
  def process_getAlerts(self, seqid, iprot, oprot):
6112 
    args = getAlerts_args()
6113 
    args.read(iprot)
6114 
    iprot.readMessageEnd()
6115 
    result = getAlerts_result()
4444 rajveer 6116 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6117 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6118 
    result.write(oprot)
6119 
    oprot.writeMessageEnd()
6120 
    oprot.trans.flush()
6121 
 
4394 rajveer 6122 
  def process_addAlert(self, seqid, iprot, oprot):
6123 
    args = addAlert_args()
3064 chandransh 6124 
    args.read(iprot)
6125 
    iprot.readMessageEnd()
4394 rajveer 6126 
    result = addAlert_result()
4444 rajveer 6127 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6128 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6129 
    result.write(oprot)
6130 
    oprot.writeMessageEnd()
6131 
    oprot.trans.flush()
6132 
 
4444 rajveer 6133 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6134 
    args = markAlertsAsSeen_args()
6135 
    args.read(iprot)
6136 
    iprot.readMessageEnd()
6137 
    result = markAlertsAsSeen_result()
6138 
    self._handler.markAlertsAsSeen(args.warehouseId)
6139 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6140 
    result.write(oprot)
6141 
    oprot.writeMessageEnd()
6142 
    oprot.trans.flush()
6143 
 
3064 chandransh 6144 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6145 
    args = getValidOrderCount_args()
6146 
    args.read(iprot)
6147 
    iprot.readMessageEnd()
6148 
    result = getValidOrderCount_result()
6149 
    result.success = self._handler.getValidOrderCount()
6150 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6151 
    result.write(oprot)
6152 
    oprot.writeMessageEnd()
6153 
    oprot.trans.flush()
6154 
 
6155 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6156 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6157 
    args.read(iprot)
6158 
    iprot.readMessageEnd()
6159 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6160 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6161 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6162 
    result.write(oprot)
6163 
    oprot.writeMessageEnd()
6164 
    oprot.trans.flush()
6165 
 
6166 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6167 
    args = getValidOrdersAmountRange_args()
6168 
    args.read(iprot)
6169 
    iprot.readMessageEnd()
6170 
    result = getValidOrdersAmountRange_result()
6171 
    result.success = self._handler.getValidOrdersAmountRange()
6172 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6173 
    result.write(oprot)
6174 
    oprot.writeMessageEnd()
6175 
    oprot.trans.flush()
6176 
 
6177 
  def process_getValidOrders(self, seqid, iprot, oprot):
6178 
    args = getValidOrders_args()
6179 
    args.read(iprot)
6180 
    iprot.readMessageEnd()
6181 
    result = getValidOrders_result()
6182 
    result.success = self._handler.getValidOrders(args.limit)
6183 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6184 
    result.write(oprot)
6185 
    oprot.writeMessageEnd()
6186 
    oprot.trans.flush()
6187 
 
1220 chandransh 6188 
  def process_batchOrders(self, seqid, iprot, oprot):
6189 
    args = batchOrders_args()
6190 
    args.read(iprot)
6191 
    iprot.readMessageEnd()
6192 
    result = batchOrders_result()
6193 
    try:
6194 
      result.success = self._handler.batchOrders(args.warehouseId)
6195 
    except TransactionServiceException, ex:
6196 
      result.ex = ex
6197 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6198 
    result.write(oprot)
6199 
    oprot.writeMessageEnd()
6200 
    oprot.trans.flush()
6201 
 
1208 chandransh 6202 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6203 
    args = markOrderAsOutOfStock_args()
6204 
    args.read(iprot)
6205 
    iprot.readMessageEnd()
6206 
    result = markOrderAsOutOfStock_result()
6207 
    try:
6208 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6209 
    except TransactionServiceException, ex:
6210 
      result.ex = ex
6211 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6212 
    result.write(oprot)
6213 
    oprot.writeMessageEnd()
6214 
    oprot.trans.flush()
6215 
 
3064 chandransh 6216 
  def process_verifyOrder(self, seqid, iprot, oprot):
6217 
    args = verifyOrder_args()
759 chandransh 6218 
    args.read(iprot)
6219 
    iprot.readMessageEnd()
3064 chandransh 6220 
    result = verifyOrder_result()
759 chandransh 6221 
    try:
3064 chandransh 6222 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6223 
    except TransactionServiceException, ex:
6224 
      result.ex = ex
3064 chandransh 6225 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6226 
    result.write(oprot)
6227 
    oprot.writeMessageEnd()
6228 
    oprot.trans.flush()
6229 
 
3064 chandransh 6230 
  def process_acceptOrder(self, seqid, iprot, oprot):
6231 
    args = acceptOrder_args()
1113 chandransh 6232 
    args.read(iprot)
6233 
    iprot.readMessageEnd()
3064 chandransh 6234 
    result = acceptOrder_result()
1113 chandransh 6235 
    try:
3064 chandransh 6236 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6237 
    except TransactionServiceException, ex:
6238 
      result.ex = ex
3064 chandransh 6239 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 6240 
    result.write(oprot)
6241 
    oprot.writeMessageEnd()
6242 
    oprot.trans.flush()
6243 
 
3064 chandransh 6244 
  def process_addBillingDetails(self, seqid, iprot, oprot):
6245 
    args = addBillingDetails_args()
1135 chandransh 6246 
    args.read(iprot)
6247 
    iprot.readMessageEnd()
3064 chandransh 6248 
    result = addBillingDetails_result()
1135 chandransh 6249 
    try:
5110 mandeep.dh 6250 
      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 6251 
    except TransactionServiceException, ex:
6252 
      result.ex = ex
3064 chandransh 6253 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 6254 
    result.write(oprot)
6255 
    oprot.writeMessageEnd()
6256 
    oprot.trans.flush()
6257 
 
4579 rajveer 6258 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
6259 
    args = addInvoiceNumber_args()
6260 
    args.read(iprot)
6261 
    iprot.readMessageEnd()
6262 
    result = addInvoiceNumber_result()
6263 
    try:
4763 rajveer 6264 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 6265 
    except TransactionServiceException, ex:
6266 
      result.ex = ex
6267 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
6268 
    result.write(oprot)
6269 
    oprot.writeMessageEnd()
6270 
    oprot.trans.flush()
6271 
 
4410 rajveer 6272 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
6273 
    args = markOrdersAsShippedFromWarehouse_args()
6274 
    args.read(iprot)
6275 
    iprot.readMessageEnd()
6276 
    result = markOrdersAsShippedFromWarehouse_result()
6277 
    try:
4789 rajveer 6278 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 6279 
    except TransactionServiceException, ex:
6280 
      result.ex = ex
6281 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
6282 
    result.write(oprot)
6283 
    oprot.writeMessageEnd()
6284 
    oprot.trans.flush()
6285 
 
5676 rajveer 6286 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
6287 
    args = markOrdersAsReturnedFromStore_args()
6288 
    args.read(iprot)
6289 
    iprot.readMessageEnd()
6290 
    result = markOrdersAsReturnedFromStore_result()
6291 
    try:
5713 rajveer 6292 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 6293 
    except TransactionServiceException, ex:
6294 
      result.ex = ex
6295 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
6296 
    result.write(oprot)
6297 
    oprot.writeMessageEnd()
6298 
    oprot.trans.flush()
6299 
 
3064 chandransh 6300 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
6301 
    args = markOrdersAsPickedUp_args()
304 ashish 6302 
    args.read(iprot)
6303 
    iprot.readMessageEnd()
3064 chandransh 6304 
    result = markOrdersAsPickedUp_result()
6305 
    try:
4910 phani.kuma 6306 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 6307 
    except TransactionServiceException, ex:
6308 
      result.ex = ex
6309 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 6310 
    result.write(oprot)
6311 
    oprot.writeMessageEnd()
6312 
    oprot.trans.flush()
94 ashish 6313 
 
4910 phani.kuma 6314 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
6315 
    args = getOrdersNotPickedUp_args()
6316 
    args.read(iprot)
6317 
    iprot.readMessageEnd()
6318 
    result = getOrdersNotPickedUp_result()
6319 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
6320 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
6321 
    result.write(oprot)
6322 
    oprot.writeMessageEnd()
6323 
    oprot.trans.flush()
6324 
 
3064 chandransh 6325 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
6326 
    args = markOrdersAsDelivered_args()
304 ashish 6327 
    args.read(iprot)
6328 
    iprot.readMessageEnd()
3064 chandransh 6329 
    result = markOrdersAsDelivered_result()
6330 
    try:
6331 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
6332 
    except TransactionServiceException, ex:
6333 
      result.ex = ex
6334 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 6335 
    result.write(oprot)
6336 
    oprot.writeMessageEnd()
6337 
    oprot.trans.flush()
6338 
 
4910 phani.kuma 6339 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
6340 
    args = markAsRTOrders_args()
1596 ankur.sing 6341 
    args.read(iprot)
6342 
    iprot.readMessageEnd()
4910 phani.kuma 6343 
    result = markAsRTOrders_result()
3064 chandransh 6344 
    try:
4910 phani.kuma 6345 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 6346 
    except TransactionServiceException, ex:
6347 
      result.ex = ex
4910 phani.kuma 6348 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 6349 
    result.write(oprot)
6350 
    oprot.writeMessageEnd()
6351 
    oprot.trans.flush()
304 ashish 6352 
 
4910 phani.kuma 6353 
  def process_getRTOrders(self, seqid, iprot, oprot):
6354 
    args = getRTOrders_args()
6355 
    args.read(iprot)
6356 
    iprot.readMessageEnd()
6357 
    result = getRTOrders_result()
6358 
    result.success = self._handler.getRTOrders(args.providerId)
6359 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
6360 
    result.write(oprot)
6361 
    oprot.writeMessageEnd()
6362 
    oprot.trans.flush()
6363 
 
3064 chandransh 6364 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
6365 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 6366 
    args.read(iprot)
6367 
    iprot.readMessageEnd()
3064 chandransh 6368 
    result = updateNonDeliveryReason_result()
6369 
    try:
4910 phani.kuma 6370 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 6371 
    except TransactionServiceException, ex:
6372 
      result.ex = ex
6373 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 6374 
    result.write(oprot)
6375 
    oprot.writeMessageEnd()
6376 
    oprot.trans.flush()
1596 ankur.sing 6377 
 
4910 phani.kuma 6378 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
6379 
    args = getNonDeliveredOrdersbyCourier_args()
6380 
    args.read(iprot)
6381 
    iprot.readMessageEnd()
6382 
    result = getNonDeliveredOrdersbyCourier_result()
6383 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
6384 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
6385 
    result.write(oprot)
6386 
    oprot.writeMessageEnd()
6387 
    oprot.trans.flush()
6388 
 
6389 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
6390 
    args = markOrdersAsLocalConnected_args()
6391 
    args.read(iprot)
6392 
    iprot.readMessageEnd()
6393 
    result = markOrdersAsLocalConnected_result()
6394 
    try:
6395 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
6396 
    except TransactionServiceException, ex:
6397 
      result.ex = ex
6398 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
6399 
    result.write(oprot)
6400 
    oprot.writeMessageEnd()
6401 
    oprot.trans.flush()
6402 
 
6403 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
6404 
    args = getOrdersNotLocalConnected_args()
6405 
    args.read(iprot)
6406 
    iprot.readMessageEnd()
6407 
    result = getOrdersNotLocalConnected_result()
6408 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
6409 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
6410 
    result.write(oprot)
6411 
    oprot.writeMessageEnd()
6412 
    oprot.trans.flush()
6413 
 
6414 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
6415 
    args = markOrdersAsDestinationCityReached_args()
6416 
    args.read(iprot)
6417 
    iprot.readMessageEnd()
6418 
    result = markOrdersAsDestinationCityReached_result()
6419 
    try:
6420 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
6421 
    except TransactionServiceException, ex:
6422 
      result.ex = ex
6423 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
6424 
    result.write(oprot)
6425 
    oprot.writeMessageEnd()
6426 
    oprot.trans.flush()
6427 
 
6428 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
6429 
    args = markOrdersAsFirstDeliveryAttempted_args()
6430 
    args.read(iprot)
6431 
    iprot.readMessageEnd()
6432 
    result = markOrdersAsFirstDeliveryAttempted_result()
6433 
    try:
6434 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
6435 
    except TransactionServiceException, ex:
6436 
      result.ex = ex
6437 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
6438 
    result.write(oprot)
6439 
    oprot.writeMessageEnd()
6440 
    oprot.trans.flush()
6441 
 
3064 chandransh 6442 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
6443 
    args = getUndeliveredOrders_args()
1627 ankur.sing 6444 
    args.read(iprot)
6445 
    iprot.readMessageEnd()
3064 chandransh 6446 
    result = getUndeliveredOrders_result()
6447 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
6448 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 6449 
    result.write(oprot)
6450 
    oprot.writeMessageEnd()
6451 
    oprot.trans.flush()
6452 
 
4783 phani.kuma 6453 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
6454 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
6455 
    args.read(iprot)
6456 
    iprot.readMessageEnd()
6457 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
6458 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
6459 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
6460 
    result.write(oprot)
6461 
    oprot.writeMessageEnd()
6462 
    oprot.trans.flush()
6463 
 
2536 chandransh 6464 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
6465 
    args = toggleDOAFlag_args()
6466 
    args.read(iprot)
6467 
    iprot.readMessageEnd()
6468 
    result = toggleDOAFlag_result()
6469 
    try:
6470 
      result.success = self._handler.toggleDOAFlag(args.orderId)
6471 
    except TransactionServiceException, ex:
6472 
      result.ex = ex
6473 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
6474 
    result.write(oprot)
6475 
    oprot.writeMessageEnd()
6476 
    oprot.trans.flush()
1886 ankur.sing 6477 
 
4712 rajveer 6478 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
6479 
    args = markOrderAsDelivered_args()
6480 
    args.read(iprot)
6481 
    iprot.readMessageEnd()
6482 
    result = markOrderAsDelivered_result()
6483 
    try:
6484 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
6485 
    except TransactionServiceException, ex:
6486 
      result.ex = ex
6487 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
6488 
    result.write(oprot)
6489 
    oprot.writeMessageEnd()
6490 
    oprot.trans.flush()
6491 
 
5553 rajveer 6492 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
6493 
    args = markOrderAsReceivedAtStore_args()
6494 
    args.read(iprot)
6495 
    iprot.readMessageEnd()
6496 
    result = markOrderAsReceivedAtStore_result()
6497 
    try:
6498 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
6499 
    except TransactionServiceException, ex:
6500 
      result.ex = ex
6501 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
6502 
    result.write(oprot)
6503 
    oprot.writeMessageEnd()
6504 
    oprot.trans.flush()
6505 
 
4454 rajveer 6506 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
6507 
    args = markOrderDoaRequestReceived_args()
6508 
    args.read(iprot)
6509 
    iprot.readMessageEnd()
6510 
    result = markOrderDoaRequestReceived_result()
6511 
    try:
6512 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
6513 
    except TransactionServiceException, ex:
6514 
      result.ex = ex
6515 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
6516 
    result.write(oprot)
6517 
    oprot.writeMessageEnd()
6518 
    oprot.trans.flush()
6519 
 
6520 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
6521 
    args = markOrderDoaRequestAuthorized_args()
6522 
    args.read(iprot)
6523 
    iprot.readMessageEnd()
6524 
    result = markOrderDoaRequestAuthorized_result()
6525 
    try:
6526 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
6527 
    except TransactionServiceException, ex:
6528 
      result.ex = ex
6529 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
6530 
    result.write(oprot)
6531 
    oprot.writeMessageEnd()
6532 
    oprot.trans.flush()
6533 
 
4488 rajveer 6534 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
6535 
    args = markOrderReturnRequestReceived_args()
6536 
    args.read(iprot)
6537 
    iprot.readMessageEnd()
6538 
    result = markOrderReturnRequestReceived_result()
6539 
    try:
6540 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
6541 
    except TransactionServiceException, ex:
6542 
      result.ex = ex
6543 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
6544 
    result.write(oprot)
6545 
    oprot.writeMessageEnd()
6546 
    oprot.trans.flush()
6547 
 
6548 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
6549 
    args = markOrderReturnRequestAuthorized_args()
6550 
    args.read(iprot)
6551 
    iprot.readMessageEnd()
6552 
    result = markOrderReturnRequestAuthorized_result()
6553 
    try:
6554 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
6555 
    except TransactionServiceException, ex:
6556 
      result.ex = ex
6557 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
6558 
    result.write(oprot)
6559 
    oprot.writeMessageEnd()
6560 
    oprot.trans.flush()
6561 
 
2536 chandransh 6562 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
6563 
    args = requestPickupNumber_args()
6564 
    args.read(iprot)
6565 
    iprot.readMessageEnd()
6566 
    result = requestPickupNumber_result()
6567 
    try:
4579 rajveer 6568 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 6569 
    except TransactionServiceException, ex:
6570 
      result.ex = ex
6571 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
6572 
    result.write(oprot)
6573 
    oprot.writeMessageEnd()
6574 
    oprot.trans.flush()
6575 
 
6576 
  def process_authorizePickup(self, seqid, iprot, oprot):
6577 
    args = authorizePickup_args()
6578 
    args.read(iprot)
6579 
    iprot.readMessageEnd()
6580 
    result = authorizePickup_result()
6581 
    try:
4602 rajveer 6582 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 6583 
    except TransactionServiceException, ex:
6584 
      result.ex = ex
6585 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
6586 
    result.write(oprot)
6587 
    oprot.writeMessageEnd()
6588 
    oprot.trans.flush()
6589 
 
2764 chandransh 6590 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
6591 
    args = markDoasAsPickedUp_args()
6592 
    args.read(iprot)
6593 
    iprot.readMessageEnd()
6594 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 6595 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 6596 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
6597 
    result.write(oprot)
6598 
    oprot.writeMessageEnd()
6599 
    oprot.trans.flush()
6600 
 
4910 phani.kuma 6601 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
6602 
    args = getDoasNotPickedUp_args()
6603 
    args.read(iprot)
6604 
    iprot.readMessageEnd()
6605 
    result = getDoasNotPickedUp_result()
6606 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
6607 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
6608 
    result.write(oprot)
6609 
    oprot.writeMessageEnd()
6610 
    oprot.trans.flush()
6611 
 
4741 phani.kuma 6612 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
6613 
    args = markReturnOrdersAsPickedUp_args()
6614 
    args.read(iprot)
6615 
    iprot.readMessageEnd()
6616 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 6617 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 6618 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
6619 
    result.write(oprot)
6620 
    oprot.writeMessageEnd()
6621 
    oprot.trans.flush()
6622 
 
4910 phani.kuma 6623 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
6624 
    args = getReturnOrdersNotPickedUp_args()
6625 
    args.read(iprot)
6626 
    iprot.readMessageEnd()
6627 
    result = getReturnOrdersNotPickedUp_result()
6628 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
6629 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
6630 
    result.write(oprot)
6631 
    oprot.writeMessageEnd()
6632 
    oprot.trans.flush()
6633 
 
2616 chandransh 6634 
  def process_receiveReturn(self, seqid, iprot, oprot):
6635 
    args = receiveReturn_args()
2591 chandransh 6636 
    args.read(iprot)
6637 
    iprot.readMessageEnd()
2616 chandransh 6638 
    result = receiveReturn_result()
2591 chandransh 6639 
    try:
4479 rajveer 6640 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 6641 
    except TransactionServiceException, ex:
6642 
      result.ex = ex
2616 chandransh 6643 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 6644 
    result.write(oprot)
6645 
    oprot.writeMessageEnd()
6646 
    oprot.trans.flush()
2536 chandransh 6647 
 
2591 chandransh 6648 
  def process_validateDoa(self, seqid, iprot, oprot):
6649 
    args = validateDoa_args()
6650 
    args.read(iprot)
6651 
    iprot.readMessageEnd()
6652 
    result = validateDoa_result()
6653 
    try:
6654 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
6655 
    except TransactionServiceException, ex:
6656 
      result.ex = ex
6657 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
6658 
    result.write(oprot)
6659 
    oprot.writeMessageEnd()
6660 
    oprot.trans.flush()
6661 
 
4495 rajveer 6662 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
6663 
    args = validateReturnProduct_args()
6664 
    args.read(iprot)
6665 
    iprot.readMessageEnd()
6666 
    result = validateReturnProduct_result()
6667 
    try:
6668 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
6669 
    except TransactionServiceException, ex:
6670 
      result.ex = ex
6671 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
6672 
    result.write(oprot)
6673 
    oprot.writeMessageEnd()
6674 
    oprot.trans.flush()
6675 
 
2616 chandransh 6676 
  def process_reshipOrder(self, seqid, iprot, oprot):
6677 
    args = reshipOrder_args()
6678 
    args.read(iprot)
6679 
    iprot.readMessageEnd()
6680 
    result = reshipOrder_result()
6681 
    try:
6682 
      result.success = self._handler.reshipOrder(args.orderId)
6683 
    except TransactionServiceException, ex:
6684 
      result.ex = ex
6685 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
6686 
    result.write(oprot)
6687 
    oprot.writeMessageEnd()
6688 
    oprot.trans.flush()
2591 chandransh 6689 
 
2616 chandransh 6690 
  def process_refundOrder(self, seqid, iprot, oprot):
6691 
    args = refundOrder_args()
6692 
    args.read(iprot)
6693 
    iprot.readMessageEnd()
6694 
    result = refundOrder_result()
6695 
    try:
3226 chandransh 6696 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 6697 
    except TransactionServiceException, ex:
6698 
      result.ex = ex
6699 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
6700 
    result.write(oprot)
6701 
    oprot.writeMessageEnd()
6702 
    oprot.trans.flush()
6703 
 
2690 chandransh 6704 
  def process_getReturnOrders(self, seqid, iprot, oprot):
6705 
    args = getReturnOrders_args()
6706 
    args.read(iprot)
6707 
    iprot.readMessageEnd()
6708 
    result = getReturnOrders_result()
6709 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
6710 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
6711 
    result.write(oprot)
6712 
    oprot.writeMessageEnd()
6713 
    oprot.trans.flush()
2616 chandransh 6714 
 
5481 phani.kuma 6715 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
6716 
    args = getAllReturnOrders_args()
6717 
    args.read(iprot)
6718 
    iprot.readMessageEnd()
6719 
    result = getAllReturnOrders_result()
6720 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
6721 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
6722 
    result.write(oprot)
6723 
    oprot.writeMessageEnd()
6724 
    oprot.trans.flush()
6725 
 
2700 chandransh 6726 
  def process_getReturnOrder(self, seqid, iprot, oprot):
6727 
    args = getReturnOrder_args()
6728 
    args.read(iprot)
6729 
    iprot.readMessageEnd()
6730 
    result = getReturnOrder_result()
6731 
    try:
6732 
      result.success = self._handler.getReturnOrder(args.id)
6733 
    except TransactionServiceException, ex:
6734 
      result.ex = ex
6735 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
6736 
    result.write(oprot)
6737 
    oprot.writeMessageEnd()
6738 
    oprot.trans.flush()
6739 
 
2690 chandransh 6740 
  def process_processReturn(self, seqid, iprot, oprot):
6741 
    args = processReturn_args()
6742 
    args.read(iprot)
6743 
    iprot.readMessageEnd()
6744 
    result = processReturn_result()
6745 
    try:
6746 
      self._handler.processReturn(args.returnOrderId)
6747 
    except TransactionServiceException, ex:
6748 
      result.ex = ex
6749 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
6750 
    result.write(oprot)
6751 
    oprot.writeMessageEnd()
6752 
    oprot.trans.flush()
6753 
 
3451 chandransh 6754 
  def process_updateWeight(self, seqid, iprot, oprot):
6755 
    args = updateWeight_args()
6756 
    args.read(iprot)
6757 
    iprot.readMessageEnd()
6758 
    result = updateWeight_result()
6759 
    try:
6760 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6761 
    except TransactionServiceException, ex:
6762 
      result.ex = ex
6763 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6764 
    result.write(oprot)
6765 
    oprot.writeMessageEnd()
6766 
    oprot.trans.flush()
2819 chandransh 6767 
 
3469 chandransh 6768 
  def process_changeItem(self, seqid, iprot, oprot):
6769 
    args = changeItem_args()
6770 
    args.read(iprot)
6771 
    iprot.readMessageEnd()
6772 
    result = changeItem_result()
6773 
    try:
6774 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6775 
    except TransactionServiceException, ex:
6776 
      result.ex = ex
6777 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6778 
    result.write(oprot)
6779 
    oprot.writeMessageEnd()
6780 
    oprot.trans.flush()
3451 chandransh 6781 
 
3469 chandransh 6782 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6783 
    args = shiftToWarehouse_args()
6784 
    args.read(iprot)
6785 
    iprot.readMessageEnd()
6786 
    result = shiftToWarehouse_result()
6787 
    try:
6788 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6789 
    except TransactionServiceException, ex:
6790 
      result.ex = ex
6791 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6792 
    result.write(oprot)
6793 
    oprot.writeMessageEnd()
6794 
    oprot.trans.flush()
6795 
 
3553 chandransh 6796 
  def process_addDelayReason(self, seqid, iprot, oprot):
6797 
    args = addDelayReason_args()
6798 
    args.read(iprot)
6799 
    iprot.readMessageEnd()
6800 
    result = addDelayReason_result()
6801 
    try:
4647 rajveer 6802 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6803 
    except TransactionServiceException, ex:
6804 
      result.ex = ex
6805 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6806 
    result.write(oprot)
6807 
    oprot.writeMessageEnd()
6808 
    oprot.trans.flush()
3469 chandransh 6809 
 
3956 chandransh 6810 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6811 
    args = reconcileCodCollection_args()
6812 
    args.read(iprot)
6813 
    iprot.readMessageEnd()
6814 
    result = reconcileCodCollection_result()
6815 
    try:
6816 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6817 
    except TransactionServiceException, ex:
6818 
      result.ex = ex
6819 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6820 
    result.write(oprot)
6821 
    oprot.writeMessageEnd()
6822 
    oprot.trans.flush()
3553 chandransh 6823 
 
4008 mandeep.dh 6824 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6825 
    args = getTransactionsRequiringExtraProcessing_args()
6826 
    args.read(iprot)
6827 
    iprot.readMessageEnd()
6828 
    result = getTransactionsRequiringExtraProcessing_result()
6829 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6830 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6831 
    result.write(oprot)
6832 
    oprot.writeMessageEnd()
6833 
    oprot.trans.flush()
3956 chandransh 6834 
 
4008 mandeep.dh 6835 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6836 
    args = markTransactionAsProcessed_args()
6837 
    args.read(iprot)
6838 
    iprot.readMessageEnd()
6839 
    result = markTransactionAsProcessed_result()
6840 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6841 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6842 
    result.write(oprot)
6843 
    oprot.writeMessageEnd()
6844 
    oprot.trans.flush()
6845 
 
4018 chandransh 6846 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6847 
    args = getItemWiseRiskyOrdersCount_args()
6848 
    args.read(iprot)
6849 
    iprot.readMessageEnd()
6850 
    result = getItemWiseRiskyOrdersCount_result()
6851 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6852 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6853 
    result.write(oprot)
6854 
    oprot.writeMessageEnd()
6855 
    oprot.trans.flush()
4008 mandeep.dh 6856 
 
4295 varun.gupt 6857 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6858 
    args = getOrdersForItemIds_args()
6859 
    args.read(iprot)
6860 
    iprot.readMessageEnd()
6861 
    result = getOrdersForItemIds_result()
6862 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6863 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6864 
    result.write(oprot)
6865 
    oprot.writeMessageEnd()
6866 
    oprot.trans.flush()
6867 
 
4247 rajveer 6868 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6869 
    args = markOrderCancellationRequestReceived_args()
6870 
    args.read(iprot)
6871 
    iprot.readMessageEnd()
6872 
    result = markOrderCancellationRequestReceived_result()
6873 
    try:
6874 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6875 
    except TransactionServiceException, ex:
6876 
      result.ex = ex
6877 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6878 
    result.write(oprot)
6879 
    oprot.writeMessageEnd()
6880 
    oprot.trans.flush()
4018 chandransh 6881 
 
4247 rajveer 6882 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6883 
    args = markOrderCancellationRequestConfirmed_args()
6884 
    args.read(iprot)
6885 
    iprot.readMessageEnd()
6886 
    result = markOrderCancellationRequestConfirmed_result()
6887 
    try:
6888 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6889 
    except TransactionServiceException, ex:
6890 
      result.ex = ex
6891 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6892 
    result.write(oprot)
6893 
    oprot.writeMessageEnd()
6894 
    oprot.trans.flush()
6895 
 
6896 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6897 
    args = markOrderCancellationRequestDenied_args()
6898 
    args.read(iprot)
6899 
    iprot.readMessageEnd()
6900 
    result = markOrderCancellationRequestDenied_result()
6901 
    try:
6902 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6903 
    except TransactionServiceException, ex:
6904 
      result.ex = ex
6905 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6906 
    result.write(oprot)
6907 
    oprot.writeMessageEnd()
6908 
    oprot.trans.flush()
6909 
 
4258 rajveer 6910 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6911 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6912 
    args.read(iprot)
6913 
    iprot.readMessageEnd()
4258 rajveer 6914 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6915 
    try:
4258 rajveer 6916 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6917 
    except TransactionServiceException, ex:
6918 
      result.ex = ex
4258 rajveer 6919 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6920 
    result.write(oprot)
6921 
    oprot.writeMessageEnd()
6922 
    oprot.trans.flush()
6923 
 
4259 anupam.sin 6924 
  def process_refundTransaction(self, seqid, iprot, oprot):
6925 
    args = refundTransaction_args()
6926 
    args.read(iprot)
6927 
    iprot.readMessageEnd()
6928 
    result = refundTransaction_result()
6929 
    try:
6930 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6931 
    except TransactionServiceException, ex:
6932 
      result.ex = ex
6933 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6934 
    result.write(oprot)
6935 
    oprot.writeMessageEnd()
6936 
    oprot.trans.flush()
4247 rajveer 6937 
 
4324 mandeep.dh 6938 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6939 
    args = updateShipmentAddress_args()
6940 
    args.read(iprot)
6941 
    iprot.readMessageEnd()
6942 
    result = updateShipmentAddress_result()
6943 
    try:
6944 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6945 
    except TransactionServiceException, ex:
6946 
      result.ex = ex
6947 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6948 
    result.write(oprot)
6949 
    oprot.writeMessageEnd()
6950 
    oprot.trans.flush()
6951 
 
4285 rajveer 6952 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6953 
    args = acceptOrdersForItemId_args()
6954 
    args.read(iprot)
6955 
    iprot.readMessageEnd()
6956 
    result = acceptOrdersForItemId_result()
6957 
    try:
6958 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6959 
    except TransactionServiceException, ex:
6960 
      result.ex = ex
6961 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6962 
    result.write(oprot)
6963 
    oprot.writeMessageEnd()
6964 
    oprot.trans.flush()
4259 anupam.sin 6965 
 
4303 rajveer 6966 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6967 
    args = markOrdersAsPORaised_args()
6968 
    args.read(iprot)
6969 
    iprot.readMessageEnd()
6970 
    result = markOrdersAsPORaised_result()
6971 
    try:
4369 rajveer 6972 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6973 
    except TransactionServiceException, ex:
6974 
      result.ex = ex
6975 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6976 
    result.write(oprot)
6977 
    oprot.writeMessageEnd()
6978 
    oprot.trans.flush()
4285 rajveer 6979 
 
4303 rajveer 6980 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6981 
    args = markOrdersAsReversalInitiated_args()
6982 
    args.read(iprot)
6983 
    iprot.readMessageEnd()
6984 
    result = markOrdersAsReversalInitiated_result()
6985 
    try:
4369 rajveer 6986 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6987 
    except TransactionServiceException, ex:
6988 
      result.ex = ex
6989 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6990 
    result.write(oprot)
6991 
    oprot.writeMessageEnd()
6992 
    oprot.trans.flush()
6993 
 
6994 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6995 
    args = markOrdersAsNotAvailabke_args()
6996 
    args.read(iprot)
6997 
    iprot.readMessageEnd()
6998 
    result = markOrdersAsNotAvailabke_result()
6999 
    try:
4369 rajveer 7000 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7001 
    except TransactionServiceException, ex:
7002 
      result.ex = ex
7003 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7004 
    result.write(oprot)
7005 
    oprot.writeMessageEnd()
7006 
    oprot.trans.flush()
7007 
 
4369 rajveer 7008 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7009 
    args = markOrdersAsTimeout_args()
7010 
    args.read(iprot)
7011 
    iprot.readMessageEnd()
7012 
    result = markOrdersAsTimeout_result()
7013 
    try:
7014 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7015 
    except TransactionServiceException, ex:
7016 
      result.ex = ex
7017 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7018 
    result.write(oprot)
7019 
    oprot.writeMessageEnd()
7020 
    oprot.trans.flush()
4303 rajveer 7021 
 
4662 rajveer 7022 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7023 
    args = markOrderAsLostInTransit_args()
7024 
    args.read(iprot)
7025 
    iprot.readMessageEnd()
7026 
    result = markOrderAsLostInTransit_result()
7027 
    try:
7028 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7029 
    except TransactionServiceException, ex:
7030 
      result.ex = ex
7031 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7032 
    result.write(oprot)
7033 
    oprot.writeMessageEnd()
7034 
    oprot.trans.flush()
7035 
 
4386 anupam.sin 7036 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7037 
    args = getOrderForAwb_args()
7038 
    args.read(iprot)
7039 
    iprot.readMessageEnd()
7040 
    result = getOrderForAwb_result()
7041 
    try:
7042 
      result.success = self._handler.getOrderForAwb(args.awb)
7043 
    except TransactionServiceException, ex:
7044 
      result.ex = ex
7045 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7046 
    result.write(oprot)
7047 
    oprot.writeMessageEnd()
7048 
    oprot.trans.flush()
4369 rajveer 7049 
 
4506 phani.kuma 7050 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7051 
    args = getOrdersForProviderForStatus_args()
7052 
    args.read(iprot)
7053 
    iprot.readMessageEnd()
7054 
    result = getOrdersForProviderForStatus_result()
7055 
    try:
4910 phani.kuma 7056 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7057 
    except TransactionServiceException, ex:
7058 
      result.ex = ex
7059 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7060 
    result.write(oprot)
7061 
    oprot.writeMessageEnd()
7062 
    oprot.trans.flush()
4386 anupam.sin 7063 
 
4600 varun.gupt 7064 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7065 
    args = getBilledOrdersForVendor_args()
7066 
    args.read(iprot)
7067 
    iprot.readMessageEnd()
7068 
    result = getBilledOrdersForVendor_result()
7069 
    try:
7070 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7071 
    except TransactionServiceException, ex:
7072 
      result.ex = ex
7073 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7074 
    result.write(oprot)
7075 
    oprot.writeMessageEnd()
7076 
    oprot.trans.flush()
4506 phani.kuma 7077 
 
4607 rajveer 7078 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7079 
    args = getSlippedSippingDateOrders_args()
7080 
    args.read(iprot)
7081 
    iprot.readMessageEnd()
7082 
    result = getSlippedSippingDateOrders_result()
7083 
    try:
7084 
      result.success = self._handler.getSlippedSippingDateOrders()
7085 
    except TransactionServiceException, ex:
7086 
      result.ex = ex
7087 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7088 
    result.write(oprot)
7089 
    oprot.writeMessageEnd()
7090 
    oprot.trans.flush()
7091 
 
4709 rajveer 7092 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7093 
    args = getCancelledOrders_args()
7094 
    args.read(iprot)
7095 
    iprot.readMessageEnd()
7096 
    result = getCancelledOrders_result()
7097 
    try:
7098 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7099 
    except TransactionServiceException, ex:
7100 
      result.ex = ex
7101 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7102 
    result.write(oprot)
7103 
    oprot.writeMessageEnd()
7104 
    oprot.trans.flush()
7105 
 
4600 varun.gupt 7106 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7107 
    args = saveBluedartSettlements_args()
7108 
    args.read(iprot)
7109 
    iprot.readMessageEnd()
7110 
    result = saveBluedartSettlements_result()
7111 
    try:
7112 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7113 
    except TransactionServiceException, ex:
7114 
      result.ex = ex
7115 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7116 
    result.write(oprot)
7117 
    oprot.writeMessageEnd()
7118 
    oprot.trans.flush()
7119 
 
7120 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7121 
    args = savePaymentSettlements_args()
7122 
    args.read(iprot)
7123 
    iprot.readMessageEnd()
7124 
    result = savePaymentSettlements_result()
7125 
    try:
4905 varun.gupt 7126 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7127 
    except TransactionServiceException, ex:
7128 
      result.ex = ex
7129 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7130 
    result.write(oprot)
7131 
    oprot.writeMessageEnd()
7132 
    oprot.trans.flush()
7133 
 
7134 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7135 
    args = saveEBSSettlementSummary_args()
7136 
    args.read(iprot)
7137 
    iprot.readMessageEnd()
7138 
    result = saveEBSSettlementSummary_result()
7139 
    try:
7140 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7141 
    except TransactionServiceException, ex:
7142 
      result.ex = ex
7143 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7144 
    result.write(oprot)
7145 
    oprot.writeMessageEnd()
7146 
    oprot.trans.flush()
7147 
 
5386 phani.kuma 7148 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7149 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7150 
    args.read(iprot)
7151 
    iprot.readMessageEnd()
5386 phani.kuma 7152 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7153 
    try:
5386 phani.kuma 7154 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7155 
    except TransactionServiceException, ex:
7156 
      result.ex = ex
5386 phani.kuma 7157 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7158 
    result.write(oprot)
7159 
    oprot.writeMessageEnd()
7160 
    oprot.trans.flush()
7161 
 
5386 phani.kuma 7162 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7163 
    args = getSettlementForCod_args()
7164 
    args.read(iprot)
7165 
    iprot.readMessageEnd()
7166 
    result = getSettlementForCod_result()
7167 
    try:
7168 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7169 
    except TransactionServiceException, ex:
7170 
      result.ex = ex
7171 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7172 
    result.write(oprot)
7173 
    oprot.writeMessageEnd()
7174 
    oprot.trans.flush()
7175 
 
4600 varun.gupt 7176 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7177 
    args = getEBSSettlementSummaries_args()
7178 
    args.read(iprot)
7179 
    iprot.readMessageEnd()
7180 
    result = getEBSSettlementSummaries_result()
7181 
    try:
7182 
      result.success = self._handler.getEBSSettlementSummaries()
7183 
    except TransactionServiceException, ex:
7184 
      result.ex = ex
7185 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7186 
    result.write(oprot)
7187 
    oprot.writeMessageEnd()
7188 
    oprot.trans.flush()
7189 
 
7190 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7191 
    args = markEBSSettlementUploaded_args()
7192 
    args.read(iprot)
7193 
    iprot.readMessageEnd()
7194 
    result = markEBSSettlementUploaded_result()
7195 
    try:
7196 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7197 
    except TransactionServiceException, ex:
7198 
      result.ex = ex
7199 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7200 
    result.write(oprot)
7201 
    oprot.writeMessageEnd()
7202 
    oprot.trans.flush()
7203 
 
7204 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7205 
    args = getEBSSettlementDate_args()
7206 
    args.read(iprot)
7207 
    iprot.readMessageEnd()
7208 
    result = getEBSSettlementDate_result()
7209 
    try:
7210 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7211 
    except TransactionServiceException, ex:
7212 
      result.ex = ex
7213 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7214 
    result.write(oprot)
7215 
    oprot.writeMessageEnd()
7216 
    oprot.trans.flush()
7217 
 
4715 varun.gupt 7218 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7219 
    args = getSettlementsByDate_args()
7220 
    args.read(iprot)
7221 
    iprot.readMessageEnd()
7222 
    result = getSettlementsByDate_result()
7223 
    try:
7224 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7225 
    except TransactionServiceException, ex:
7226 
      result.ex = ex
7227 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7228 
    result.write(oprot)
7229 
    oprot.writeMessageEnd()
7230 
    oprot.trans.flush()
4600 varun.gupt 7231 
 
4715 varun.gupt 7232 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7233 
    args = getReshippedOrderIds_args()
7234 
    args.read(iprot)
7235 
    iprot.readMessageEnd()
7236 
    result = getReshippedOrderIds_result()
7237 
    try:
7238 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
7239 
    except TransactionServiceException, ex:
7240 
      result.ex = ex
7241 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
7242 
    result.write(oprot)
7243 
    oprot.writeMessageEnd()
7244 
    oprot.trans.flush()
7245 
 
5481 phani.kuma 7246 
  def process_getBilledOrders(self, seqid, iprot, oprot):
7247 
    args = getBilledOrders_args()
4875 varun.gupt 7248 
    args.read(iprot)
7249 
    iprot.readMessageEnd()
5481 phani.kuma 7250 
    result = getBilledOrders_result()
4875 varun.gupt 7251 
    try:
5481 phani.kuma 7252 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 7253 
    except TransactionServiceException, ex:
7254 
      result.ex = ex
5481 phani.kuma 7255 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 7256 
    result.write(oprot)
7257 
    oprot.writeMessageEnd()
7258 
    oprot.trans.flush()
4757 mandeep.dh 7259 
 
5031 varun.gupt 7260 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
7261 
    args = getStatusDistributionOfOrders_args()
7262 
    args.read(iprot)
7263 
    iprot.readMessageEnd()
7264 
    result = getStatusDistributionOfOrders_result()
7265 
    try:
7266 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
7267 
    except TransactionServiceException, ex:
7268 
      result.ex = ex
7269 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
7270 
    result.write(oprot)
7271 
    oprot.writeMessageEnd()
7272 
    oprot.trans.flush()
4875 varun.gupt 7273 
 
5067 varun.gupt 7274 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
7275 
    args = getOrderIdsForStatus_args()
7276 
    args.read(iprot)
7277 
    iprot.readMessageEnd()
7278 
    result = getOrderIdsForStatus_result()
7279 
    try:
7280 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
7281 
    except TransactionServiceException, ex:
7282 
      result.ex = ex
7283 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
7284 
    result.write(oprot)
7285 
    oprot.writeMessageEnd()
7286 
    oprot.trans.flush()
5031 varun.gupt 7287 
 
5348 anupam.sin 7288 
  def process_updateCODAgent(self, seqid, iprot, oprot):
7289 
    args = updateCODAgent_args()
7290 
    args.read(iprot)
7291 
    iprot.readMessageEnd()
7292 
    result = updateCODAgent_result()
7293 
    try:
7294 
      self._handler.updateCODAgent(args.agent, args.orderId)
7295 
    except TransactionServiceException, ex:
7296 
      result.ex = ex
7297 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
7298 
    result.write(oprot)
7299 
    oprot.writeMessageEnd()
7300 
    oprot.trans.flush()
7301 
 
5099 varun.gupt 7302 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
7303 
    args = updateOrderAsPaidToVendor_args()
7304 
    args.read(iprot)
7305 
    iprot.readMessageEnd()
7306 
    result = updateOrderAsPaidToVendor_result()
7307 
    try:
7308 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
7309 
    except TransactionServiceException, ex:
7310 
      result.ex = ex
7311 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
7312 
    result.write(oprot)
7313 
    oprot.writeMessageEnd()
7314 
    oprot.trans.flush()
5067 varun.gupt 7315 
 
5386 phani.kuma 7316 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
7317 
    args = updateOrderOnlyAsPaidToVendor_args()
7318 
    args.read(iprot)
7319 
    iprot.readMessageEnd()
7320 
    result = updateOrderOnlyAsPaidToVendor_result()
7321 
    try:
7322 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
7323 
    except TransactionServiceException, ex:
7324 
      result.ex = ex
7325 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
7326 
    result.write(oprot)
7327 
    oprot.writeMessageEnd()
7328 
    oprot.trans.flush()
7329 
 
5208 varun.gupt 7330 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
7331 
    args = getRefundedOrdersMarkedPaid_args()
7332 
    args.read(iprot)
7333 
    iprot.readMessageEnd()
7334 
    result = getRefundedOrdersMarkedPaid_result()
7335 
    try:
7336 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
7337 
    except TransactionServiceException, ex:
7338 
      result.ex = ex
7339 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
7340 
    result.write(oprot)
7341 
    oprot.writeMessageEnd()
7342 
    oprot.trans.flush()
5099 varun.gupt 7343 
 
5447 anupam.sin 7344 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
7345 
    args = getAllVerificationAgents_args()
7346 
    args.read(iprot)
7347 
    iprot.readMessageEnd()
7348 
    result = getAllVerificationAgents_result()
7349 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
7350 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
7351 
    result.write(oprot)
7352 
    oprot.writeMessageEnd()
7353 
    oprot.trans.flush()
5208 varun.gupt 7354 
 
5527 anupam.sin 7355 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
7356 
    args = getAllAttributesForOrderId_args()
7357 
    args.read(iprot)
7358 
    iprot.readMessageEnd()
7359 
    result = getAllAttributesForOrderId_result()
7360 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
7361 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
7362 
    result.write(oprot)
7363 
    oprot.writeMessageEnd()
7364 
    oprot.trans.flush()
5447 anupam.sin 7365 
 
5676 rajveer 7366 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
7367 
    args = setOrderAttributes_args()
7368 
    args.read(iprot)
7369 
    iprot.readMessageEnd()
7370 
    result = setOrderAttributes_result()
7371 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
7372 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
7373 
    result.write(oprot)
7374 
    oprot.writeMessageEnd()
7375 
    oprot.trans.flush()
7376 
 
5527 anupam.sin 7377 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
7378 
    args = setOrderAttributeForTransaction_args()
7379 
    args.read(iprot)
7380 
    iprot.readMessageEnd()
7381 
    result = setOrderAttributeForTransaction_result()
7382 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
7383 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
7384 
    result.write(oprot)
7385 
    oprot.writeMessageEnd()
7386 
    oprot.trans.flush()
7387 
 
5553 rajveer 7388 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
7389 
    args = getReceivePendingOrders_args()
7390 
    args.read(iprot)
7391 
    iprot.readMessageEnd()
7392 
    result = getReceivePendingOrders_result()
7393 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
7394 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
7395 
    result.write(oprot)
7396 
    oprot.writeMessageEnd()
7397 
    oprot.trans.flush()
5527 anupam.sin 7398 
 
5553 rajveer 7399 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
7400 
    args = getReceivedAtStoreOrders_args()
7401 
    args.read(iprot)
7402 
    iprot.readMessageEnd()
7403 
    result = getReceivedAtStoreOrders_result()
7404 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
7405 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
7406 
    result.write(oprot)
7407 
    oprot.writeMessageEnd()
7408 
    oprot.trans.flush()
7409 
 
5713 rajveer 7410 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
7411 
    args = getOrdersCollectionAtStore_args()
7412 
    args.read(iprot)
7413 
    iprot.readMessageEnd()
7414 
    result = getOrdersCollectionAtStore_result()
7415 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
7416 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
7417 
    result.write(oprot)
7418 
    oprot.writeMessageEnd()
7419 
    oprot.trans.flush()
7420 
 
5833 rajveer 7421 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
7422 
    args = getOrderAttributeValue_args()
7423 
    args.read(iprot)
7424 
    iprot.readMessageEnd()
7425 
    result = getOrderAttributeValue_result()
7426 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
7427 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
7428 
    result.write(oprot)
7429 
    oprot.writeMessageEnd()
7430 
    oprot.trans.flush()
7431 
 
5593 mandeep.dh 7432 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
7433 
    args = acceptOrderForItem_args()
7434 
    args.read(iprot)
7435 
    iprot.readMessageEnd()
7436 
    result = acceptOrderForItem_result()
7437 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
7438 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
7439 
    result.write(oprot)
7440 
    oprot.writeMessageEnd()
7441 
    oprot.trans.flush()
5553 rajveer 7442 
 
5593 mandeep.dh 7443 
 
94 ashish 7444 
# HELPER FUNCTIONS AND STRUCTURES
7445 
 
7446 
class createTransaction_args:
7447 
  """
7448 
  Attributes:
7449 
   - transaction
7450 
  """
7451 
 
7452 
  thrift_spec = (
7453 
    None, # 0
7454 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
7455 
  )
7456 
 
7457 
  def __init__(self, transaction=None,):
7458 
    self.transaction = transaction
7459 
 
7460 
  def read(self, iprot):
7461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7463 
      return
7464 
    iprot.readStructBegin()
7465 
    while True:
7466 
      (fname, ftype, fid) = iprot.readFieldBegin()
7467 
      if ftype == TType.STOP:
7468 
        break
7469 
      if fid == 1:
7470 
        if ftype == TType.STRUCT:
7471 
          self.transaction = Transaction()
7472 
          self.transaction.read(iprot)
7473 
        else:
7474 
          iprot.skip(ftype)
7475 
      else:
7476 
        iprot.skip(ftype)
7477 
      iprot.readFieldEnd()
7478 
    iprot.readStructEnd()
7479 
 
7480 
  def write(self, oprot):
7481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7483 
      return
7484 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 7485 
    if self.transaction is not None:
94 ashish 7486 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
7487 
      self.transaction.write(oprot)
7488 
      oprot.writeFieldEnd()
7489 
    oprot.writeFieldStop()
7490 
    oprot.writeStructEnd()
7491 
 
3431 rajveer 7492 
  def validate(self):
7493 
    return
7494 
 
7495 
 
94 ashish 7496 
  def __repr__(self):
7497 
    L = ['%s=%r' % (key, value)
7498 
      for key, value in self.__dict__.iteritems()]
7499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7500 
 
7501 
  def __eq__(self, other):
7502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7503 
 
7504 
  def __ne__(self, other):
7505 
    return not (self == other)
7506 
 
7507 
class createTransaction_result:
7508 
  """
7509 
  Attributes:
132 ashish 7510 
   - success
94 ashish 7511 
   - ex
7512 
  """
7513 
 
7514 
  thrift_spec = (
132 ashish 7515 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7516 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7517 
  )
7518 
 
132 ashish 7519 
  def __init__(self, success=None, ex=None,):
7520 
    self.success = success
94 ashish 7521 
    self.ex = ex
7522 
 
7523 
  def read(self, iprot):
7524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7526 
      return
7527 
    iprot.readStructBegin()
7528 
    while True:
7529 
      (fname, ftype, fid) = iprot.readFieldBegin()
7530 
      if ftype == TType.STOP:
7531 
        break
132 ashish 7532 
      if fid == 0:
7533 
        if ftype == TType.I64:
7534 
          self.success = iprot.readI64();
7535 
        else:
7536 
          iprot.skip(ftype)
7537 
      elif fid == 1:
94 ashish 7538 
        if ftype == TType.STRUCT:
7539 
          self.ex = TransactionServiceException()
7540 
          self.ex.read(iprot)
7541 
        else:
7542 
          iprot.skip(ftype)
7543 
      else:
7544 
        iprot.skip(ftype)
7545 
      iprot.readFieldEnd()
7546 
    iprot.readStructEnd()
7547 
 
7548 
  def write(self, oprot):
7549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7551 
      return
7552 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 7553 
    if self.success is not None:
132 ashish 7554 
      oprot.writeFieldBegin('success', TType.I64, 0)
7555 
      oprot.writeI64(self.success)
7556 
      oprot.writeFieldEnd()
3431 rajveer 7557 
    if self.ex is not None:
94 ashish 7558 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7559 
      self.ex.write(oprot)
7560 
      oprot.writeFieldEnd()
7561 
    oprot.writeFieldStop()
7562 
    oprot.writeStructEnd()
7563 
 
3431 rajveer 7564 
  def validate(self):
7565 
    return
7566 
 
7567 
 
94 ashish 7568 
  def __repr__(self):
7569 
    L = ['%s=%r' % (key, value)
7570 
      for key, value in self.__dict__.iteritems()]
7571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7572 
 
7573 
  def __eq__(self, other):
7574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7575 
 
7576 
  def __ne__(self, other):
7577 
    return not (self == other)
7578 
 
7579 
class getTransaction_args:
7580 
  """
7581 
  Attributes:
7582 
   - id
7583 
  """
7584 
 
7585 
  thrift_spec = (
7586 
    None, # 0
7587 
    (1, TType.I64, 'id', None, None, ), # 1
7588 
  )
7589 
 
7590 
  def __init__(self, id=None,):
7591 
    self.id = id
7592 
 
7593 
  def read(self, iprot):
7594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7596 
      return
7597 
    iprot.readStructBegin()
7598 
    while True:
7599 
      (fname, ftype, fid) = iprot.readFieldBegin()
7600 
      if ftype == TType.STOP:
7601 
        break
7602 
      if fid == 1:
7603 
        if ftype == TType.I64:
7604 
          self.id = iprot.readI64();
7605 
        else:
7606 
          iprot.skip(ftype)
7607 
      else:
7608 
        iprot.skip(ftype)
7609 
      iprot.readFieldEnd()
7610 
    iprot.readStructEnd()
7611 
 
7612 
  def write(self, oprot):
7613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7615 
      return
7616 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 7617 
    if self.id is not None:
94 ashish 7618 
      oprot.writeFieldBegin('id', TType.I64, 1)
7619 
      oprot.writeI64(self.id)
7620 
      oprot.writeFieldEnd()
7621 
    oprot.writeFieldStop()
7622 
    oprot.writeStructEnd()
7623 
 
3431 rajveer 7624 
  def validate(self):
7625 
    return
7626 
 
7627 
 
94 ashish 7628 
  def __repr__(self):
7629 
    L = ['%s=%r' % (key, value)
7630 
      for key, value in self.__dict__.iteritems()]
7631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7632 
 
7633 
  def __eq__(self, other):
7634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7635 
 
7636 
  def __ne__(self, other):
7637 
    return not (self == other)
7638 
 
7639 
class getTransaction_result:
7640 
  """
7641 
  Attributes:
7642 
   - success
7643 
   - ex
7644 
  """
7645 
 
7646 
  thrift_spec = (
7647 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
7648 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7649 
  )
7650 
 
7651 
  def __init__(self, success=None, ex=None,):
7652 
    self.success = success
7653 
    self.ex = ex
7654 
 
7655 
  def read(self, iprot):
7656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7658 
      return
7659 
    iprot.readStructBegin()
7660 
    while True:
7661 
      (fname, ftype, fid) = iprot.readFieldBegin()
7662 
      if ftype == TType.STOP:
7663 
        break
7664 
      if fid == 0:
7665 
        if ftype == TType.STRUCT:
7666 
          self.success = Transaction()
7667 
          self.success.read(iprot)
7668 
        else:
7669 
          iprot.skip(ftype)
7670 
      elif fid == 1:
7671 
        if ftype == TType.STRUCT:
7672 
          self.ex = TransactionServiceException()
7673 
          self.ex.read(iprot)
7674 
        else:
7675 
          iprot.skip(ftype)
7676 
      else:
7677 
        iprot.skip(ftype)
7678 
      iprot.readFieldEnd()
7679 
    iprot.readStructEnd()
7680 
 
7681 
  def write(self, oprot):
7682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7684 
      return
7685 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 7686 
    if self.success is not None:
94 ashish 7687 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7688 
      self.success.write(oprot)
7689 
      oprot.writeFieldEnd()
3431 rajveer 7690 
    if self.ex is not None:
94 ashish 7691 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7692 
      self.ex.write(oprot)
7693 
      oprot.writeFieldEnd()
7694 
    oprot.writeFieldStop()
7695 
    oprot.writeStructEnd()
7696 
 
3431 rajveer 7697 
  def validate(self):
7698 
    return
7699 
 
7700 
 
94 ashish 7701 
  def __repr__(self):
7702 
    L = ['%s=%r' % (key, value)
7703 
      for key, value in self.__dict__.iteritems()]
7704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7705 
 
7706 
  def __eq__(self, other):
7707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7708 
 
7709 
  def __ne__(self, other):
7710 
    return not (self == other)
7711 
 
7712 
class getTransactionsForCustomer_args:
7713 
  """
7714 
  Attributes:
7715 
   - customerId
7716 
   - from_date
7717 
   - to_date
7718 
   - status
7719 
  """
7720 
 
7721 
  thrift_spec = (
7722 
    None, # 0
7723 
    (1, TType.I64, 'customerId', None, None, ), # 1
7724 
    (2, TType.I64, 'from_date', None, None, ), # 2
7725 
    (3, TType.I64, 'to_date', None, None, ), # 3
7726 
    (4, TType.I32, 'status', None, None, ), # 4
7727 
  )
7728 
 
7729 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
7730 
    self.customerId = customerId
7731 
    self.from_date = from_date
7732 
    self.to_date = to_date
7733 
    self.status = status
7734 
 
7735 
  def read(self, iprot):
7736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7738 
      return
7739 
    iprot.readStructBegin()
7740 
    while True:
7741 
      (fname, ftype, fid) = iprot.readFieldBegin()
7742 
      if ftype == TType.STOP:
7743 
        break
7744 
      if fid == 1:
7745 
        if ftype == TType.I64:
7746 
          self.customerId = iprot.readI64();
7747 
        else:
7748 
          iprot.skip(ftype)
7749 
      elif fid == 2:
7750 
        if ftype == TType.I64:
7751 
          self.from_date = iprot.readI64();
7752 
        else:
7753 
          iprot.skip(ftype)
7754 
      elif fid == 3:
7755 
        if ftype == TType.I64:
7756 
          self.to_date = iprot.readI64();
7757 
        else:
7758 
          iprot.skip(ftype)
7759 
      elif fid == 4:
7760 
        if ftype == TType.I32:
7761 
          self.status = iprot.readI32();
7762 
        else:
7763 
          iprot.skip(ftype)
7764 
      else:
7765 
        iprot.skip(ftype)
7766 
      iprot.readFieldEnd()
7767 
    iprot.readStructEnd()
7768 
 
7769 
  def write(self, oprot):
7770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7772 
      return
7773 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 7774 
    if self.customerId is not None:
94 ashish 7775 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7776 
      oprot.writeI64(self.customerId)
7777 
      oprot.writeFieldEnd()
3431 rajveer 7778 
    if self.from_date is not None:
94 ashish 7779 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7780 
      oprot.writeI64(self.from_date)
7781 
      oprot.writeFieldEnd()
3431 rajveer 7782 
    if self.to_date is not None:
94 ashish 7783 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7784 
      oprot.writeI64(self.to_date)
7785 
      oprot.writeFieldEnd()
3431 rajveer 7786 
    if self.status is not None:
94 ashish 7787 
      oprot.writeFieldBegin('status', TType.I32, 4)
7788 
      oprot.writeI32(self.status)
7789 
      oprot.writeFieldEnd()
7790 
    oprot.writeFieldStop()
7791 
    oprot.writeStructEnd()
7792 
 
3431 rajveer 7793 
  def validate(self):
7794 
    return
7795 
 
7796 
 
94 ashish 7797 
  def __repr__(self):
7798 
    L = ['%s=%r' % (key, value)
7799 
      for key, value in self.__dict__.iteritems()]
7800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7801 
 
7802 
  def __eq__(self, other):
7803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7804 
 
7805 
  def __ne__(self, other):
7806 
    return not (self == other)
7807 
 
7808 
class getTransactionsForCustomer_result:
7809 
  """
7810 
  Attributes:
7811 
   - success
7812 
   - ex
7813 
  """
7814 
 
7815 
  thrift_spec = (
7816 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7817 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7818 
  )
7819 
 
7820 
  def __init__(self, success=None, ex=None,):
7821 
    self.success = success
7822 
    self.ex = ex
7823 
 
7824 
  def read(self, iprot):
7825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7827 
      return
7828 
    iprot.readStructBegin()
7829 
    while True:
7830 
      (fname, ftype, fid) = iprot.readFieldBegin()
7831 
      if ftype == TType.STOP:
7832 
        break
7833 
      if fid == 0:
7834 
        if ftype == TType.LIST:
7835 
          self.success = []
5031 varun.gupt 7836 
          (_etype66, _size63) = iprot.readListBegin()
7837 
          for _i67 in xrange(_size63):
7838 
            _elem68 = Transaction()
7839 
            _elem68.read(iprot)
7840 
            self.success.append(_elem68)
94 ashish 7841 
          iprot.readListEnd()
7842 
        else:
7843 
          iprot.skip(ftype)
7844 
      elif fid == 1:
7845 
        if ftype == TType.STRUCT:
7846 
          self.ex = TransactionServiceException()
7847 
          self.ex.read(iprot)
7848 
        else:
7849 
          iprot.skip(ftype)
7850 
      else:
7851 
        iprot.skip(ftype)
7852 
      iprot.readFieldEnd()
7853 
    iprot.readStructEnd()
7854 
 
7855 
  def write(self, oprot):
7856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7858 
      return
7859 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 7860 
    if self.success is not None:
94 ashish 7861 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7862 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7863 
      for iter69 in self.success:
7864 
        iter69.write(oprot)
94 ashish 7865 
      oprot.writeListEnd()
7866 
      oprot.writeFieldEnd()
3431 rajveer 7867 
    if self.ex is not None:
94 ashish 7868 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7869 
      self.ex.write(oprot)
7870 
      oprot.writeFieldEnd()
7871 
    oprot.writeFieldStop()
7872 
    oprot.writeStructEnd()
7873 
 
3431 rajveer 7874 
  def validate(self):
7875 
    return
7876 
 
7877 
 
94 ashish 7878 
  def __repr__(self):
7879 
    L = ['%s=%r' % (key, value)
7880 
      for key, value in self.__dict__.iteritems()]
7881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7882 
 
7883 
  def __eq__(self, other):
7884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7885 
 
7886 
  def __ne__(self, other):
7887 
    return not (self == other)
7888 
 
132 ashish 7889 
class getTransactionsForShoppingCartId_args:
7890 
  """
7891 
  Attributes:
7892 
   - shoppingCartId
7893 
  """
7894 
 
7895 
  thrift_spec = (
7896 
    None, # 0
7897 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
7898 
  )
7899 
 
7900 
  def __init__(self, shoppingCartId=None,):
7901 
    self.shoppingCartId = shoppingCartId
7902 
 
7903 
  def read(self, iprot):
7904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7906 
      return
7907 
    iprot.readStructBegin()
7908 
    while True:
7909 
      (fname, ftype, fid) = iprot.readFieldBegin()
7910 
      if ftype == TType.STOP:
7911 
        break
7912 
      if fid == 1:
7913 
        if ftype == TType.I64:
7914 
          self.shoppingCartId = iprot.readI64();
7915 
        else:
7916 
          iprot.skip(ftype)
7917 
      else:
7918 
        iprot.skip(ftype)
7919 
      iprot.readFieldEnd()
7920 
    iprot.readStructEnd()
7921 
 
7922 
  def write(self, oprot):
7923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7925 
      return
7926 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 7927 
    if self.shoppingCartId is not None:
132 ashish 7928 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
7929 
      oprot.writeI64(self.shoppingCartId)
7930 
      oprot.writeFieldEnd()
7931 
    oprot.writeFieldStop()
7932 
    oprot.writeStructEnd()
7933 
 
3431 rajveer 7934 
  def validate(self):
7935 
    return
7936 
 
7937 
 
132 ashish 7938 
  def __repr__(self):
7939 
    L = ['%s=%r' % (key, value)
7940 
      for key, value in self.__dict__.iteritems()]
7941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7942 
 
7943 
  def __eq__(self, other):
7944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7945 
 
7946 
  def __ne__(self, other):
7947 
    return not (self == other)
7948 
 
7949 
class getTransactionsForShoppingCartId_result:
7950 
  """
7951 
  Attributes:
7952 
   - success
7953 
   - ex
7954 
  """
7955 
 
7956 
  thrift_spec = (
7957 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7958 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7959 
  )
7960 
 
7961 
  def __init__(self, success=None, ex=None,):
7962 
    self.success = success
7963 
    self.ex = ex
7964 
 
7965 
  def read(self, iprot):
7966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7968 
      return
7969 
    iprot.readStructBegin()
7970 
    while True:
7971 
      (fname, ftype, fid) = iprot.readFieldBegin()
7972 
      if ftype == TType.STOP:
7973 
        break
7974 
      if fid == 0:
7975 
        if ftype == TType.LIST:
7976 
          self.success = []
5031 varun.gupt 7977 
          (_etype73, _size70) = iprot.readListBegin()
7978 
          for _i74 in xrange(_size70):
7979 
            _elem75 = Transaction()
7980 
            _elem75.read(iprot)
7981 
            self.success.append(_elem75)
132 ashish 7982 
          iprot.readListEnd()
7983 
        else:
7984 
          iprot.skip(ftype)
7985 
      elif fid == 1:
7986 
        if ftype == TType.STRUCT:
7987 
          self.ex = TransactionServiceException()
7988 
          self.ex.read(iprot)
7989 
        else:
7990 
          iprot.skip(ftype)
7991 
      else:
7992 
        iprot.skip(ftype)
7993 
      iprot.readFieldEnd()
7994 
    iprot.readStructEnd()
7995 
 
7996 
  def write(self, oprot):
7997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7999 
      return
8000 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 8001 
    if self.success is not None:
132 ashish 8002 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8003 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8004 
      for iter76 in self.success:
8005 
        iter76.write(oprot)
132 ashish 8006 
      oprot.writeListEnd()
8007 
      oprot.writeFieldEnd()
3431 rajveer 8008 
    if self.ex is not None:
132 ashish 8009 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8010 
      self.ex.write(oprot)
8011 
      oprot.writeFieldEnd()
8012 
    oprot.writeFieldStop()
8013 
    oprot.writeStructEnd()
8014 
 
3431 rajveer 8015 
  def validate(self):
8016 
    return
8017 
 
8018 
 
132 ashish 8019 
  def __repr__(self):
8020 
    L = ['%s=%r' % (key, value)
8021 
      for key, value in self.__dict__.iteritems()]
8022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8023 
 
8024 
  def __eq__(self, other):
8025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8026 
 
8027 
  def __ne__(self, other):
8028 
    return not (self == other)
8029 
 
94 ashish 8030 
class getTransactionStatus_args:
8031 
  """
8032 
  Attributes:
8033 
   - transactionId
8034 
  """
8035 
 
8036 
  thrift_spec = (
8037 
    None, # 0
8038 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8039 
  )
8040 
 
8041 
  def __init__(self, transactionId=None,):
8042 
    self.transactionId = transactionId
8043 
 
8044 
  def read(self, iprot):
8045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8047 
      return
8048 
    iprot.readStructBegin()
8049 
    while True:
8050 
      (fname, ftype, fid) = iprot.readFieldBegin()
8051 
      if ftype == TType.STOP:
8052 
        break
8053 
      if fid == 1:
8054 
        if ftype == TType.I64:
8055 
          self.transactionId = iprot.readI64();
8056 
        else:
8057 
          iprot.skip(ftype)
8058 
      else:
8059 
        iprot.skip(ftype)
8060 
      iprot.readFieldEnd()
8061 
    iprot.readStructEnd()
8062 
 
8063 
  def write(self, oprot):
8064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8066 
      return
8067 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 8068 
    if self.transactionId is not None:
94 ashish 8069 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8070 
      oprot.writeI64(self.transactionId)
8071 
      oprot.writeFieldEnd()
8072 
    oprot.writeFieldStop()
8073 
    oprot.writeStructEnd()
8074 
 
3431 rajveer 8075 
  def validate(self):
8076 
    return
8077 
 
8078 
 
94 ashish 8079 
  def __repr__(self):
8080 
    L = ['%s=%r' % (key, value)
8081 
      for key, value in self.__dict__.iteritems()]
8082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8083 
 
8084 
  def __eq__(self, other):
8085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8086 
 
8087 
  def __ne__(self, other):
8088 
    return not (self == other)
8089 
 
8090 
class getTransactionStatus_result:
8091 
  """
8092 
  Attributes:
8093 
   - success
8094 
   - ex
8095 
  """
8096 
 
8097 
  thrift_spec = (
8098 
    (0, TType.I32, 'success', None, None, ), # 0
8099 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8100 
  )
8101 
 
8102 
  def __init__(self, success=None, ex=None,):
8103 
    self.success = success
8104 
    self.ex = ex
8105 
 
8106 
  def read(self, iprot):
8107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8109 
      return
8110 
    iprot.readStructBegin()
8111 
    while True:
8112 
      (fname, ftype, fid) = iprot.readFieldBegin()
8113 
      if ftype == TType.STOP:
8114 
        break
8115 
      if fid == 0:
8116 
        if ftype == TType.I32:
8117 
          self.success = iprot.readI32();
8118 
        else:
8119 
          iprot.skip(ftype)
8120 
      elif fid == 1:
8121 
        if ftype == TType.STRUCT:
8122 
          self.ex = TransactionServiceException()
8123 
          self.ex.read(iprot)
8124 
        else:
8125 
          iprot.skip(ftype)
8126 
      else:
8127 
        iprot.skip(ftype)
8128 
      iprot.readFieldEnd()
8129 
    iprot.readStructEnd()
8130 
 
8131 
  def write(self, oprot):
8132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8134 
      return
8135 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 8136 
    if self.success is not None:
94 ashish 8137 
      oprot.writeFieldBegin('success', TType.I32, 0)
8138 
      oprot.writeI32(self.success)
8139 
      oprot.writeFieldEnd()
3431 rajveer 8140 
    if self.ex is not None:
94 ashish 8141 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8142 
      self.ex.write(oprot)
8143 
      oprot.writeFieldEnd()
8144 
    oprot.writeFieldStop()
8145 
    oprot.writeStructEnd()
8146 
 
3431 rajveer 8147 
  def validate(self):
8148 
    return
8149 
 
8150 
 
94 ashish 8151 
  def __repr__(self):
8152 
    L = ['%s=%r' % (key, value)
8153 
      for key, value in self.__dict__.iteritems()]
8154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8155 
 
8156 
  def __eq__(self, other):
8157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8158 
 
8159 
  def __ne__(self, other):
8160 
    return not (self == other)
8161 
 
8162 
class changeTransactionStatus_args:
8163 
  """
8164 
  Attributes:
8165 
   - transactionId
8166 
   - status
8167 
   - description
5527 anupam.sin 8168 
   - pickUp
8169 
   - orderType
94 ashish 8170 
  """
8171 
 
8172 
  thrift_spec = (
8173 
    None, # 0
8174 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8175 
    (2, TType.I32, 'status', None, None, ), # 2
8176 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 8177 
    (4, TType.I64, 'pickUp', None, None, ), # 4
8178 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 8179 
  )
8180 
 
5527 anupam.sin 8181 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 8182 
    self.transactionId = transactionId
8183 
    self.status = status
8184 
    self.description = description
5527 anupam.sin 8185 
    self.pickUp = pickUp
8186 
    self.orderType = orderType
94 ashish 8187 
 
8188 
  def read(self, iprot):
8189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8191 
      return
8192 
    iprot.readStructBegin()
8193 
    while True:
8194 
      (fname, ftype, fid) = iprot.readFieldBegin()
8195 
      if ftype == TType.STOP:
8196 
        break
8197 
      if fid == 1:
8198 
        if ftype == TType.I64:
8199 
          self.transactionId = iprot.readI64();
8200 
        else:
8201 
          iprot.skip(ftype)
8202 
      elif fid == 2:
8203 
        if ftype == TType.I32:
8204 
          self.status = iprot.readI32();
8205 
        else:
8206 
          iprot.skip(ftype)
8207 
      elif fid == 3:
8208 
        if ftype == TType.STRING:
8209 
          self.description = iprot.readString();
8210 
        else:
8211 
          iprot.skip(ftype)
5387 rajveer 8212 
      elif fid == 4:
5527 anupam.sin 8213 
        if ftype == TType.I64:
8214 
          self.pickUp = iprot.readI64();
5387 rajveer 8215 
        else:
8216 
          iprot.skip(ftype)
5527 anupam.sin 8217 
      elif fid == 5:
8218 
        if ftype == TType.I32:
8219 
          self.orderType = iprot.readI32();
8220 
        else:
8221 
          iprot.skip(ftype)
94 ashish 8222 
      else:
8223 
        iprot.skip(ftype)
8224 
      iprot.readFieldEnd()
8225 
    iprot.readStructEnd()
8226 
 
8227 
  def write(self, oprot):
8228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8230 
      return
8231 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 8232 
    if self.transactionId is not None:
94 ashish 8233 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8234 
      oprot.writeI64(self.transactionId)
8235 
      oprot.writeFieldEnd()
3431 rajveer 8236 
    if self.status is not None:
94 ashish 8237 
      oprot.writeFieldBegin('status', TType.I32, 2)
8238 
      oprot.writeI32(self.status)
8239 
      oprot.writeFieldEnd()
3431 rajveer 8240 
    if self.description is not None:
94 ashish 8241 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8242 
      oprot.writeString(self.description)
8243 
      oprot.writeFieldEnd()
5527 anupam.sin 8244 
    if self.pickUp is not None:
8245 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
8246 
      oprot.writeI64(self.pickUp)
5387 rajveer 8247 
      oprot.writeFieldEnd()
5527 anupam.sin 8248 
    if self.orderType is not None:
8249 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
8250 
      oprot.writeI32(self.orderType)
8251 
      oprot.writeFieldEnd()
94 ashish 8252 
    oprot.writeFieldStop()
8253 
    oprot.writeStructEnd()
8254 
 
3431 rajveer 8255 
  def validate(self):
8256 
    return
8257 
 
8258 
 
94 ashish 8259 
  def __repr__(self):
8260 
    L = ['%s=%r' % (key, value)
8261 
      for key, value in self.__dict__.iteritems()]
8262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8263 
 
8264 
  def __eq__(self, other):
8265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8266 
 
8267 
  def __ne__(self, other):
8268 
    return not (self == other)
8269 
 
8270 
class changeTransactionStatus_result:
8271 
  """
8272 
  Attributes:
8273 
   - success
8274 
   - ex
8275 
  """
8276 
 
8277 
  thrift_spec = (
8278 
    (0, TType.BOOL, 'success', None, None, ), # 0
8279 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8280 
  )
8281 
 
8282 
  def __init__(self, success=None, ex=None,):
8283 
    self.success = success
8284 
    self.ex = ex
8285 
 
8286 
  def read(self, iprot):
8287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8289 
      return
8290 
    iprot.readStructBegin()
8291 
    while True:
8292 
      (fname, ftype, fid) = iprot.readFieldBegin()
8293 
      if ftype == TType.STOP:
8294 
        break
8295 
      if fid == 0:
8296 
        if ftype == TType.BOOL:
8297 
          self.success = iprot.readBool();
8298 
        else:
8299 
          iprot.skip(ftype)
8300 
      elif fid == 1:
8301 
        if ftype == TType.STRUCT:
8302 
          self.ex = TransactionServiceException()
8303 
          self.ex.read(iprot)
8304 
        else:
8305 
          iprot.skip(ftype)
8306 
      else:
8307 
        iprot.skip(ftype)
8308 
      iprot.readFieldEnd()
8309 
    iprot.readStructEnd()
8310 
 
8311 
  def write(self, oprot):
8312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8314 
      return
8315 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 8316 
    if self.success is not None:
94 ashish 8317 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8318 
      oprot.writeBool(self.success)
8319 
      oprot.writeFieldEnd()
3431 rajveer 8320 
    if self.ex is not None:
94 ashish 8321 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8322 
      self.ex.write(oprot)
8323 
      oprot.writeFieldEnd()
8324 
    oprot.writeFieldStop()
8325 
    oprot.writeStructEnd()
8326 
 
3431 rajveer 8327 
  def validate(self):
8328 
    return
8329 
 
8330 
 
94 ashish 8331 
  def __repr__(self):
8332 
    L = ['%s=%r' % (key, value)
8333 
      for key, value in self.__dict__.iteritems()]
8334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8335 
 
8336 
  def __eq__(self, other):
8337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8338 
 
8339 
  def __ne__(self, other):
8340 
    return not (self == other)
8341 
 
1398 varun.gupt 8342 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 8343 
  """
8344 
  Attributes:
8345 
   - transactionId
8346 
  """
8347 
 
8348 
  thrift_spec = (
8349 
    None, # 0
8350 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8351 
  )
8352 
 
8353 
  def __init__(self, transactionId=None,):
8354 
    self.transactionId = transactionId
8355 
 
8356 
  def read(self, iprot):
8357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8359 
      return
8360 
    iprot.readStructBegin()
8361 
    while True:
8362 
      (fname, ftype, fid) = iprot.readFieldBegin()
8363 
      if ftype == TType.STOP:
8364 
        break
8365 
      if fid == 1:
8366 
        if ftype == TType.I64:
8367 
          self.transactionId = iprot.readI64();
8368 
        else:
8369 
          iprot.skip(ftype)
8370 
      else:
8371 
        iprot.skip(ftype)
8372 
      iprot.readFieldEnd()
8373 
    iprot.readStructEnd()
8374 
 
8375 
  def write(self, oprot):
8376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8378 
      return
1398 varun.gupt 8379 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 8380 
    if self.transactionId is not None:
1382 varun.gupt 8381 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8382 
      oprot.writeI64(self.transactionId)
8383 
      oprot.writeFieldEnd()
8384 
    oprot.writeFieldStop()
8385 
    oprot.writeStructEnd()
8386 
 
3431 rajveer 8387 
  def validate(self):
8388 
    return
8389 
 
8390 
 
1382 varun.gupt 8391 
  def __repr__(self):
8392 
    L = ['%s=%r' % (key, value)
8393 
      for key, value in self.__dict__.iteritems()]
8394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8395 
 
8396 
  def __eq__(self, other):
8397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8398 
 
8399 
  def __ne__(self, other):
8400 
    return not (self == other)
8401 
 
1398 varun.gupt 8402 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 8403 
  """
8404 
  Attributes:
8405 
   - success
8406 
   - ex
8407 
  """
8408 
 
8409 
  thrift_spec = (
8410 
    (0, TType.BOOL, 'success', None, None, ), # 0
8411 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8412 
  )
8413 
 
8414 
  def __init__(self, success=None, ex=None,):
8415 
    self.success = success
8416 
    self.ex = ex
8417 
 
8418 
  def read(self, iprot):
8419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8421 
      return
8422 
    iprot.readStructBegin()
8423 
    while True:
8424 
      (fname, ftype, fid) = iprot.readFieldBegin()
8425 
      if ftype == TType.STOP:
8426 
        break
8427 
      if fid == 0:
8428 
        if ftype == TType.BOOL:
8429 
          self.success = iprot.readBool();
8430 
        else:
8431 
          iprot.skip(ftype)
8432 
      elif fid == 1:
8433 
        if ftype == TType.STRUCT:
8434 
          self.ex = TransactionServiceException()
8435 
          self.ex.read(iprot)
8436 
        else:
8437 
          iprot.skip(ftype)
8438 
      else:
8439 
        iprot.skip(ftype)
8440 
      iprot.readFieldEnd()
8441 
    iprot.readStructEnd()
8442 
 
8443 
  def write(self, oprot):
8444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8446 
      return
1398 varun.gupt 8447 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 8448 
    if self.success is not None:
1382 varun.gupt 8449 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8450 
      oprot.writeBool(self.success)
8451 
      oprot.writeFieldEnd()
3431 rajveer 8452 
    if self.ex is not None:
1382 varun.gupt 8453 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8454 
      self.ex.write(oprot)
8455 
      oprot.writeFieldEnd()
8456 
    oprot.writeFieldStop()
8457 
    oprot.writeStructEnd()
8458 
 
3431 rajveer 8459 
  def validate(self):
8460 
    return
8461 
 
8462 
 
1382 varun.gupt 8463 
  def __repr__(self):
8464 
    L = ['%s=%r' % (key, value)
8465 
      for key, value in self.__dict__.iteritems()]
8466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8467 
 
8468 
  def __eq__(self, other):
8469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8470 
 
8471 
  def __ne__(self, other):
8472 
    return not (self == other)
8473 
 
483 rajveer 8474 
class getAllOrders_args:
94 ashish 8475 
  """
8476 
  Attributes:
4801 anupam.sin 8477 
   - statuses
483 rajveer 8478 
   - from_date
8479 
   - to_date
8480 
   - warehouse_id
94 ashish 8481 
  """
8482 
 
8483 
  thrift_spec = (
8484 
    None, # 0
4801 anupam.sin 8485 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 8486 
    (2, TType.I64, 'from_date', None, None, ), # 2
8487 
    (3, TType.I64, 'to_date', None, None, ), # 3
8488 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 8489 
  )
8490 
 
4801 anupam.sin 8491 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
8492 
    self.statuses = statuses
483 rajveer 8493 
    self.from_date = from_date
8494 
    self.to_date = to_date
8495 
    self.warehouse_id = warehouse_id
94 ashish 8496 
 
8497 
  def read(self, iprot):
8498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8500 
      return
8501 
    iprot.readStructBegin()
8502 
    while True:
8503 
      (fname, ftype, fid) = iprot.readFieldBegin()
8504 
      if ftype == TType.STOP:
8505 
        break
8506 
      if fid == 1:
4801 anupam.sin 8507 
        if ftype == TType.LIST:
8508 
          self.statuses = []
5031 varun.gupt 8509 
          (_etype80, _size77) = iprot.readListBegin()
8510 
          for _i81 in xrange(_size77):
8511 
            _elem82 = iprot.readI32();
8512 
            self.statuses.append(_elem82)
4801 anupam.sin 8513 
          iprot.readListEnd()
94 ashish 8514 
        else:
8515 
          iprot.skip(ftype)
483 rajveer 8516 
      elif fid == 2:
8517 
        if ftype == TType.I64:
8518 
          self.from_date = iprot.readI64();
94 ashish 8519 
        else:
8520 
          iprot.skip(ftype)
483 rajveer 8521 
      elif fid == 3:
8522 
        if ftype == TType.I64:
8523 
          self.to_date = iprot.readI64();
94 ashish 8524 
        else:
8525 
          iprot.skip(ftype)
483 rajveer 8526 
      elif fid == 4:
94 ashish 8527 
        if ftype == TType.I64:
483 rajveer 8528 
          self.warehouse_id = iprot.readI64();
94 ashish 8529 
        else:
8530 
          iprot.skip(ftype)
8531 
      else:
8532 
        iprot.skip(ftype)
8533 
      iprot.readFieldEnd()
8534 
    iprot.readStructEnd()
8535 
 
8536 
  def write(self, oprot):
8537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8539 
      return
483 rajveer 8540 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 8541 
    if self.statuses is not None:
8542 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8543 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8544 
      for iter83 in self.statuses:
8545 
        oprot.writeI32(iter83)
4801 anupam.sin 8546 
      oprot.writeListEnd()
94 ashish 8547 
      oprot.writeFieldEnd()
3431 rajveer 8548 
    if self.from_date is not None:
483 rajveer 8549 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8550 
      oprot.writeI64(self.from_date)
94 ashish 8551 
      oprot.writeFieldEnd()
3431 rajveer 8552 
    if self.to_date is not None:
483 rajveer 8553 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8554 
      oprot.writeI64(self.to_date)
94 ashish 8555 
      oprot.writeFieldEnd()
3431 rajveer 8556 
    if self.warehouse_id is not None:
483 rajveer 8557 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8558 
      oprot.writeI64(self.warehouse_id)
94 ashish 8559 
      oprot.writeFieldEnd()
8560 
    oprot.writeFieldStop()
8561 
    oprot.writeStructEnd()
8562 
 
3431 rajveer 8563 
  def validate(self):
8564 
    return
8565 
 
8566 
 
94 ashish 8567 
  def __repr__(self):
8568 
    L = ['%s=%r' % (key, value)
8569 
      for key, value in self.__dict__.iteritems()]
8570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8571 
 
8572 
  def __eq__(self, other):
8573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8574 
 
8575 
  def __ne__(self, other):
8576 
    return not (self == other)
8577 
 
483 rajveer 8578 
class getAllOrders_result:
94 ashish 8579 
  """
8580 
  Attributes:
8581 
   - success
8582 
   - ex
8583 
  """
8584 
 
8585 
  thrift_spec = (
483 rajveer 8586 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 8587 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8588 
  )
8589 
 
8590 
  def __init__(self, success=None, ex=None,):
8591 
    self.success = success
8592 
    self.ex = ex
8593 
 
8594 
  def read(self, iprot):
8595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8597 
      return
8598 
    iprot.readStructBegin()
8599 
    while True:
8600 
      (fname, ftype, fid) = iprot.readFieldBegin()
8601 
      if ftype == TType.STOP:
8602 
        break
8603 
      if fid == 0:
483 rajveer 8604 
        if ftype == TType.LIST:
8605 
          self.success = []
5031 varun.gupt 8606 
          (_etype87, _size84) = iprot.readListBegin()
8607 
          for _i88 in xrange(_size84):
8608 
            _elem89 = Order()
8609 
            _elem89.read(iprot)
8610 
            self.success.append(_elem89)
483 rajveer 8611 
          iprot.readListEnd()
94 ashish 8612 
        else:
8613 
          iprot.skip(ftype)
8614 
      elif fid == 1:
8615 
        if ftype == TType.STRUCT:
8616 
          self.ex = TransactionServiceException()
8617 
          self.ex.read(iprot)
8618 
        else:
8619 
          iprot.skip(ftype)
8620 
      else:
8621 
        iprot.skip(ftype)
8622 
      iprot.readFieldEnd()
8623 
    iprot.readStructEnd()
8624 
 
8625 
  def write(self, oprot):
8626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8628 
      return
483 rajveer 8629 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 8630 
    if self.success is not None:
483 rajveer 8631 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8632 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8633 
      for iter90 in self.success:
8634 
        iter90.write(oprot)
483 rajveer 8635 
      oprot.writeListEnd()
94 ashish 8636 
      oprot.writeFieldEnd()
3431 rajveer 8637 
    if self.ex is not None:
94 ashish 8638 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8639 
      self.ex.write(oprot)
8640 
      oprot.writeFieldEnd()
8641 
    oprot.writeFieldStop()
8642 
    oprot.writeStructEnd()
8643 
 
3431 rajveer 8644 
  def validate(self):
8645 
    return
8646 
 
8647 
 
94 ashish 8648 
  def __repr__(self):
8649 
    L = ['%s=%r' % (key, value)
8650 
      for key, value in self.__dict__.iteritems()]
8651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8652 
 
8653 
  def __eq__(self, other):
8654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8655 
 
8656 
  def __ne__(self, other):
8657 
    return not (self == other)
8658 
 
4133 chandransh 8659 
class getOrdersInBatch_args:
8660 
  """
8661 
  Attributes:
8662 
   - statuses
8663 
   - offset
8664 
   - limit
8665 
   - warehouse_id
8666 
  """
8667 
 
8668 
  thrift_spec = (
8669 
    None, # 0
8670 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8671 
    (2, TType.I64, 'offset', None, None, ), # 2
8672 
    (3, TType.I64, 'limit', None, None, ), # 3
8673 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8674 
  )
8675 
 
8676 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
8677 
    self.statuses = statuses
8678 
    self.offset = offset
8679 
    self.limit = limit
8680 
    self.warehouse_id = warehouse_id
8681 
 
8682 
  def read(self, iprot):
8683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8685 
      return
8686 
    iprot.readStructBegin()
8687 
    while True:
8688 
      (fname, ftype, fid) = iprot.readFieldBegin()
8689 
      if ftype == TType.STOP:
8690 
        break
8691 
      if fid == 1:
8692 
        if ftype == TType.LIST:
8693 
          self.statuses = []
5031 varun.gupt 8694 
          (_etype94, _size91) = iprot.readListBegin()
8695 
          for _i95 in xrange(_size91):
8696 
            _elem96 = iprot.readI32();
8697 
            self.statuses.append(_elem96)
4133 chandransh 8698 
          iprot.readListEnd()
8699 
        else:
8700 
          iprot.skip(ftype)
8701 
      elif fid == 2:
8702 
        if ftype == TType.I64:
8703 
          self.offset = iprot.readI64();
8704 
        else:
8705 
          iprot.skip(ftype)
8706 
      elif fid == 3:
8707 
        if ftype == TType.I64:
8708 
          self.limit = iprot.readI64();
8709 
        else:
8710 
          iprot.skip(ftype)
8711 
      elif fid == 4:
8712 
        if ftype == TType.I64:
8713 
          self.warehouse_id = iprot.readI64();
8714 
        else:
8715 
          iprot.skip(ftype)
8716 
      else:
8717 
        iprot.skip(ftype)
8718 
      iprot.readFieldEnd()
8719 
    iprot.readStructEnd()
8720 
 
8721 
  def write(self, oprot):
8722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8724 
      return
8725 
    oprot.writeStructBegin('getOrdersInBatch_args')
8726 
    if self.statuses is not None:
8727 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8728 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8729 
      for iter97 in self.statuses:
8730 
        oprot.writeI32(iter97)
4133 chandransh 8731 
      oprot.writeListEnd()
8732 
      oprot.writeFieldEnd()
8733 
    if self.offset is not None:
8734 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8735 
      oprot.writeI64(self.offset)
8736 
      oprot.writeFieldEnd()
8737 
    if self.limit is not None:
8738 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8739 
      oprot.writeI64(self.limit)
8740 
      oprot.writeFieldEnd()
8741 
    if self.warehouse_id is not None:
8742 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8743 
      oprot.writeI64(self.warehouse_id)
8744 
      oprot.writeFieldEnd()
8745 
    oprot.writeFieldStop()
8746 
    oprot.writeStructEnd()
8747 
 
8748 
  def validate(self):
8749 
    return
8750 
 
8751 
 
8752 
  def __repr__(self):
8753 
    L = ['%s=%r' % (key, value)
8754 
      for key, value in self.__dict__.iteritems()]
8755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8756 
 
8757 
  def __eq__(self, other):
8758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8759 
 
8760 
  def __ne__(self, other):
8761 
    return not (self == other)
8762 
 
8763 
class getOrdersInBatch_result:
8764 
  """
8765 
  Attributes:
8766 
   - success
8767 
   - ex
8768 
  """
8769 
 
8770 
  thrift_spec = (
8771 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8772 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8773 
  )
8774 
 
8775 
  def __init__(self, success=None, ex=None,):
8776 
    self.success = success
8777 
    self.ex = ex
8778 
 
8779 
  def read(self, iprot):
8780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8782 
      return
8783 
    iprot.readStructBegin()
8784 
    while True:
8785 
      (fname, ftype, fid) = iprot.readFieldBegin()
8786 
      if ftype == TType.STOP:
8787 
        break
8788 
      if fid == 0:
8789 
        if ftype == TType.LIST:
8790 
          self.success = []
5031 varun.gupt 8791 
          (_etype101, _size98) = iprot.readListBegin()
8792 
          for _i102 in xrange(_size98):
8793 
            _elem103 = Order()
8794 
            _elem103.read(iprot)
8795 
            self.success.append(_elem103)
4133 chandransh 8796 
          iprot.readListEnd()
8797 
        else:
8798 
          iprot.skip(ftype)
8799 
      elif fid == 1:
8800 
        if ftype == TType.STRUCT:
8801 
          self.ex = TransactionServiceException()
8802 
          self.ex.read(iprot)
8803 
        else:
8804 
          iprot.skip(ftype)
8805 
      else:
8806 
        iprot.skip(ftype)
8807 
      iprot.readFieldEnd()
8808 
    iprot.readStructEnd()
8809 
 
8810 
  def write(self, oprot):
8811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8813 
      return
8814 
    oprot.writeStructBegin('getOrdersInBatch_result')
8815 
    if self.success is not None:
8816 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8817 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8818 
      for iter104 in self.success:
8819 
        iter104.write(oprot)
4133 chandransh 8820 
      oprot.writeListEnd()
8821 
      oprot.writeFieldEnd()
8822 
    if self.ex is not None:
8823 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8824 
      self.ex.write(oprot)
8825 
      oprot.writeFieldEnd()
8826 
    oprot.writeFieldStop()
8827 
    oprot.writeStructEnd()
8828 
 
8829 
  def validate(self):
8830 
    return
8831 
 
8832 
 
8833 
  def __repr__(self):
8834 
    L = ['%s=%r' % (key, value)
8835 
      for key, value in self.__dict__.iteritems()]
8836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8837 
 
8838 
  def __eq__(self, other):
8839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8840 
 
8841 
  def __ne__(self, other):
8842 
    return not (self == other)
8843 
 
8844 
class getOrderCount_args:
8845 
  """
8846 
  Attributes:
8847 
   - statuses
8848 
   - warehouseId
8849 
  """
8850 
 
8851 
  thrift_spec = (
8852 
    None, # 0
8853 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8854 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8855 
  )
8856 
 
8857 
  def __init__(self, statuses=None, warehouseId=None,):
8858 
    self.statuses = statuses
8859 
    self.warehouseId = warehouseId
8860 
 
8861 
  def read(self, iprot):
8862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8864 
      return
8865 
    iprot.readStructBegin()
8866 
    while True:
8867 
      (fname, ftype, fid) = iprot.readFieldBegin()
8868 
      if ftype == TType.STOP:
8869 
        break
8870 
      if fid == 1:
8871 
        if ftype == TType.LIST:
8872 
          self.statuses = []
5031 varun.gupt 8873 
          (_etype108, _size105) = iprot.readListBegin()
8874 
          for _i109 in xrange(_size105):
8875 
            _elem110 = iprot.readI32();
8876 
            self.statuses.append(_elem110)
4133 chandransh 8877 
          iprot.readListEnd()
8878 
        else:
8879 
          iprot.skip(ftype)
8880 
      elif fid == 2:
8881 
        if ftype == TType.I64:
8882 
          self.warehouseId = iprot.readI64();
8883 
        else:
8884 
          iprot.skip(ftype)
8885 
      else:
8886 
        iprot.skip(ftype)
8887 
      iprot.readFieldEnd()
8888 
    iprot.readStructEnd()
8889 
 
8890 
  def write(self, oprot):
8891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8893 
      return
8894 
    oprot.writeStructBegin('getOrderCount_args')
8895 
    if self.statuses is not None:
8896 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8897 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8898 
      for iter111 in self.statuses:
8899 
        oprot.writeI32(iter111)
4133 chandransh 8900 
      oprot.writeListEnd()
8901 
      oprot.writeFieldEnd()
8902 
    if self.warehouseId is not None:
8903 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8904 
      oprot.writeI64(self.warehouseId)
8905 
      oprot.writeFieldEnd()
8906 
    oprot.writeFieldStop()
8907 
    oprot.writeStructEnd()
8908 
 
8909 
  def validate(self):
8910 
    return
8911 
 
8912 
 
8913 
  def __repr__(self):
8914 
    L = ['%s=%r' % (key, value)
8915 
      for key, value in self.__dict__.iteritems()]
8916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8917 
 
8918 
  def __eq__(self, other):
8919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8920 
 
8921 
  def __ne__(self, other):
8922 
    return not (self == other)
8923 
 
8924 
class getOrderCount_result:
8925 
  """
8926 
  Attributes:
8927 
   - success
8928 
   - ex
8929 
  """
8930 
 
8931 
  thrift_spec = (
8932 
    (0, TType.I32, 'success', None, None, ), # 0
8933 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8934 
  )
8935 
 
8936 
  def __init__(self, success=None, ex=None,):
8937 
    self.success = success
8938 
    self.ex = ex
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 == 0:
8950 
        if ftype == TType.I32:
8951 
          self.success = iprot.readI32();
8952 
        else:
8953 
          iprot.skip(ftype)
8954 
      elif fid == 1:
8955 
        if ftype == TType.STRUCT:
8956 
          self.ex = TransactionServiceException()
8957 
          self.ex.read(iprot)
8958 
        else:
8959 
          iprot.skip(ftype)
8960 
      else:
8961 
        iprot.skip(ftype)
8962 
      iprot.readFieldEnd()
8963 
    iprot.readStructEnd()
8964 
 
8965 
  def write(self, oprot):
8966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8968 
      return
8969 
    oprot.writeStructBegin('getOrderCount_result')
8970 
    if self.success is not None:
8971 
      oprot.writeFieldBegin('success', TType.I32, 0)
8972 
      oprot.writeI32(self.success)
8973 
      oprot.writeFieldEnd()
8974 
    if self.ex is not None:
8975 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8976 
      self.ex.write(oprot)
8977 
      oprot.writeFieldEnd()
8978 
    oprot.writeFieldStop()
8979 
    oprot.writeStructEnd()
8980 
 
8981 
  def validate(self):
8982 
    return
8983 
 
8984 
 
8985 
  def __repr__(self):
8986 
    L = ['%s=%r' % (key, value)
8987 
      for key, value in self.__dict__.iteritems()]
8988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8989 
 
8990 
  def __eq__(self, other):
8991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8992 
 
8993 
  def __ne__(self, other):
8994 
    return not (self == other)
8995 
 
999 varun.gupt 8996 
class getOrdersByBillingDate_args:
8997 
  """
8998 
  Attributes:
8999 
   - status
9000 
   - start_billing_date
9001 
   - end_billing_date
9002 
   - warehouse_id
9003 
  """
9004 
 
9005 
  thrift_spec = (
9006 
    None, # 0
9007 
    (1, TType.I32, 'status', None, None, ), # 1
9008 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
9009 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
9010 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9011 
  )
9012 
 
9013 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
9014 
    self.status = status
9015 
    self.start_billing_date = start_billing_date
9016 
    self.end_billing_date = end_billing_date
9017 
    self.warehouse_id = warehouse_id
9018 
 
9019 
  def read(self, iprot):
9020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9022 
      return
9023 
    iprot.readStructBegin()
9024 
    while True:
9025 
      (fname, ftype, fid) = iprot.readFieldBegin()
9026 
      if ftype == TType.STOP:
9027 
        break
9028 
      if fid == 1:
9029 
        if ftype == TType.I32:
9030 
          self.status = iprot.readI32();
9031 
        else:
9032 
          iprot.skip(ftype)
9033 
      elif fid == 2:
9034 
        if ftype == TType.I64:
9035 
          self.start_billing_date = iprot.readI64();
9036 
        else:
9037 
          iprot.skip(ftype)
9038 
      elif fid == 3:
9039 
        if ftype == TType.I64:
9040 
          self.end_billing_date = iprot.readI64();
9041 
        else:
9042 
          iprot.skip(ftype)
9043 
      elif fid == 4:
9044 
        if ftype == TType.I64:
9045 
          self.warehouse_id = iprot.readI64();
9046 
        else:
9047 
          iprot.skip(ftype)
9048 
      else:
9049 
        iprot.skip(ftype)
9050 
      iprot.readFieldEnd()
9051 
    iprot.readStructEnd()
9052 
 
9053 
  def write(self, oprot):
9054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9056 
      return
9057 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 9058 
    if self.status is not None:
999 varun.gupt 9059 
      oprot.writeFieldBegin('status', TType.I32, 1)
9060 
      oprot.writeI32(self.status)
9061 
      oprot.writeFieldEnd()
3431 rajveer 9062 
    if self.start_billing_date is not None:
999 varun.gupt 9063 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
9064 
      oprot.writeI64(self.start_billing_date)
9065 
      oprot.writeFieldEnd()
3431 rajveer 9066 
    if self.end_billing_date is not None:
999 varun.gupt 9067 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
9068 
      oprot.writeI64(self.end_billing_date)
9069 
      oprot.writeFieldEnd()
3431 rajveer 9070 
    if self.warehouse_id is not None:
999 varun.gupt 9071 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9072 
      oprot.writeI64(self.warehouse_id)
9073 
      oprot.writeFieldEnd()
9074 
    oprot.writeFieldStop()
9075 
    oprot.writeStructEnd()
9076 
 
3431 rajveer 9077 
  def validate(self):
9078 
    return
9079 
 
9080 
 
999 varun.gupt 9081 
  def __repr__(self):
9082 
    L = ['%s=%r' % (key, value)
9083 
      for key, value in self.__dict__.iteritems()]
9084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9085 
 
9086 
  def __eq__(self, other):
9087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9088 
 
9089 
  def __ne__(self, other):
9090 
    return not (self == other)
9091 
 
9092 
class getOrdersByBillingDate_result:
9093 
  """
9094 
  Attributes:
9095 
   - success
9096 
   - ex
9097 
  """
9098 
 
9099 
  thrift_spec = (
9100 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9101 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9102 
  )
9103 
 
9104 
  def __init__(self, success=None, ex=None,):
9105 
    self.success = success
9106 
    self.ex = ex
9107 
 
9108 
  def read(self, iprot):
9109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9111 
      return
9112 
    iprot.readStructBegin()
9113 
    while True:
9114 
      (fname, ftype, fid) = iprot.readFieldBegin()
9115 
      if ftype == TType.STOP:
9116 
        break
9117 
      if fid == 0:
9118 
        if ftype == TType.LIST:
9119 
          self.success = []
5031 varun.gupt 9120 
          (_etype115, _size112) = iprot.readListBegin()
9121 
          for _i116 in xrange(_size112):
9122 
            _elem117 = Order()
9123 
            _elem117.read(iprot)
9124 
            self.success.append(_elem117)
999 varun.gupt 9125 
          iprot.readListEnd()
9126 
        else:
9127 
          iprot.skip(ftype)
9128 
      elif fid == 1:
9129 
        if ftype == TType.STRUCT:
9130 
          self.ex = TransactionServiceException()
9131 
          self.ex.read(iprot)
9132 
        else:
9133 
          iprot.skip(ftype)
9134 
      else:
9135 
        iprot.skip(ftype)
9136 
      iprot.readFieldEnd()
9137 
    iprot.readStructEnd()
9138 
 
9139 
  def write(self, oprot):
9140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9142 
      return
9143 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 9144 
    if self.success is not None:
999 varun.gupt 9145 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9146 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9147 
      for iter118 in self.success:
9148 
        iter118.write(oprot)
999 varun.gupt 9149 
      oprot.writeListEnd()
9150 
      oprot.writeFieldEnd()
3431 rajveer 9151 
    if self.ex is not None:
999 varun.gupt 9152 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9153 
      self.ex.write(oprot)
9154 
      oprot.writeFieldEnd()
9155 
    oprot.writeFieldStop()
9156 
    oprot.writeStructEnd()
9157 
 
3431 rajveer 9158 
  def validate(self):
9159 
    return
9160 
 
9161 
 
999 varun.gupt 9162 
  def __repr__(self):
9163 
    L = ['%s=%r' % (key, value)
9164 
      for key, value in self.__dict__.iteritems()]
9165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9166 
 
9167 
  def __eq__(self, other):
9168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9169 
 
9170 
  def __ne__(self, other):
9171 
    return not (self == other)
9172 
 
3427 chandransh 9173 
class getOrdersByShippingDate_args:
9174 
  """
9175 
  Attributes:
9176 
   - fromShippingDate
9177 
   - toShippingDate
9178 
   - providerId
9179 
   - warehouseId
3451 chandransh 9180 
   - cod
3427 chandransh 9181 
  """
9182 
 
9183 
  thrift_spec = (
9184 
    None, # 0
9185 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
9186 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
9187 
    (3, TType.I64, 'providerId', None, None, ), # 3
9188 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 9189 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 9190 
  )
9191 
 
3451 chandransh 9192 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 9193 
    self.fromShippingDate = fromShippingDate
9194 
    self.toShippingDate = toShippingDate
9195 
    self.providerId = providerId
9196 
    self.warehouseId = warehouseId
3451 chandransh 9197 
    self.cod = cod
3427 chandransh 9198 
 
9199 
  def read(self, iprot):
9200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9202 
      return
9203 
    iprot.readStructBegin()
9204 
    while True:
9205 
      (fname, ftype, fid) = iprot.readFieldBegin()
9206 
      if ftype == TType.STOP:
9207 
        break
9208 
      if fid == 1:
9209 
        if ftype == TType.I64:
9210 
          self.fromShippingDate = iprot.readI64();
9211 
        else:
9212 
          iprot.skip(ftype)
9213 
      elif fid == 2:
9214 
        if ftype == TType.I64:
9215 
          self.toShippingDate = iprot.readI64();
9216 
        else:
9217 
          iprot.skip(ftype)
9218 
      elif fid == 3:
9219 
        if ftype == TType.I64:
9220 
          self.providerId = iprot.readI64();
9221 
        else:
9222 
          iprot.skip(ftype)
9223 
      elif fid == 4:
9224 
        if ftype == TType.I64:
9225 
          self.warehouseId = iprot.readI64();
9226 
        else:
9227 
          iprot.skip(ftype)
3451 chandransh 9228 
      elif fid == 5:
9229 
        if ftype == TType.BOOL:
9230 
          self.cod = iprot.readBool();
9231 
        else:
9232 
          iprot.skip(ftype)
3427 chandransh 9233 
      else:
9234 
        iprot.skip(ftype)
9235 
      iprot.readFieldEnd()
9236 
    iprot.readStructEnd()
9237 
 
9238 
  def write(self, oprot):
9239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9241 
      return
9242 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 9243 
    if self.fromShippingDate is not None:
3427 chandransh 9244 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
9245 
      oprot.writeI64(self.fromShippingDate)
9246 
      oprot.writeFieldEnd()
3431 rajveer 9247 
    if self.toShippingDate is not None:
3427 chandransh 9248 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
9249 
      oprot.writeI64(self.toShippingDate)
9250 
      oprot.writeFieldEnd()
3431 rajveer 9251 
    if self.providerId is not None:
3427 chandransh 9252 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
9253 
      oprot.writeI64(self.providerId)
9254 
      oprot.writeFieldEnd()
3431 rajveer 9255 
    if self.warehouseId is not None:
3427 chandransh 9256 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
9257 
      oprot.writeI64(self.warehouseId)
9258 
      oprot.writeFieldEnd()
3451 chandransh 9259 
    if self.cod is not None:
9260 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
9261 
      oprot.writeBool(self.cod)
9262 
      oprot.writeFieldEnd()
3427 chandransh 9263 
    oprot.writeFieldStop()
9264 
    oprot.writeStructEnd()
9265 
 
3431 rajveer 9266 
  def validate(self):
9267 
    return
9268 
 
9269 
 
3427 chandransh 9270 
  def __repr__(self):
9271 
    L = ['%s=%r' % (key, value)
9272 
      for key, value in self.__dict__.iteritems()]
9273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9274 
 
9275 
  def __eq__(self, other):
9276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9277 
 
9278 
  def __ne__(self, other):
9279 
    return not (self == other)
9280 
 
9281 
class getOrdersByShippingDate_result:
9282 
  """
9283 
  Attributes:
9284 
   - success
9285 
   - ex
9286 
  """
9287 
 
9288 
  thrift_spec = (
9289 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9290 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9291 
  )
9292 
 
9293 
  def __init__(self, success=None, ex=None,):
9294 
    self.success = success
9295 
    self.ex = ex
9296 
 
9297 
  def read(self, iprot):
9298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9300 
      return
9301 
    iprot.readStructBegin()
9302 
    while True:
9303 
      (fname, ftype, fid) = iprot.readFieldBegin()
9304 
      if ftype == TType.STOP:
9305 
        break
9306 
      if fid == 0:
9307 
        if ftype == TType.LIST:
9308 
          self.success = []
5031 varun.gupt 9309 
          (_etype122, _size119) = iprot.readListBegin()
9310 
          for _i123 in xrange(_size119):
9311 
            _elem124 = Order()
9312 
            _elem124.read(iprot)
9313 
            self.success.append(_elem124)
3427 chandransh 9314 
          iprot.readListEnd()
9315 
        else:
9316 
          iprot.skip(ftype)
9317 
      elif fid == 1:
9318 
        if ftype == TType.STRUCT:
9319 
          self.ex = TransactionServiceException()
9320 
          self.ex.read(iprot)
9321 
        else:
9322 
          iprot.skip(ftype)
9323 
      else:
9324 
        iprot.skip(ftype)
9325 
      iprot.readFieldEnd()
9326 
    iprot.readStructEnd()
9327 
 
9328 
  def write(self, oprot):
9329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9331 
      return
9332 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 9333 
    if self.success is not None:
3427 chandransh 9334 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9335 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9336 
      for iter125 in self.success:
9337 
        iter125.write(oprot)
3427 chandransh 9338 
      oprot.writeListEnd()
9339 
      oprot.writeFieldEnd()
3431 rajveer 9340 
    if self.ex is not None:
3427 chandransh 9341 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9342 
      self.ex.write(oprot)
9343 
      oprot.writeFieldEnd()
9344 
    oprot.writeFieldStop()
9345 
    oprot.writeStructEnd()
9346 
 
3431 rajveer 9347 
  def validate(self):
9348 
    return
9349 
 
9350 
 
3427 chandransh 9351 
  def __repr__(self):
9352 
    L = ['%s=%r' % (key, value)
9353 
      for key, value in self.__dict__.iteritems()]
9354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9355 
 
9356 
  def __eq__(self, other):
9357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9358 
 
9359 
  def __ne__(self, other):
9360 
    return not (self == other)
9361 
 
1382 varun.gupt 9362 
class getReturnableOrdersForCustomer_args:
9363 
  """
9364 
  Attributes:
9365 
   - customer_id
9366 
   - limit
9367 
  """
9368 
 
9369 
  thrift_spec = (
9370 
    None, # 0
9371 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9372 
    (2, TType.I64, 'limit', None, None, ), # 2
9373 
  )
9374 
 
9375 
  def __init__(self, customer_id=None, limit=None,):
9376 
    self.customer_id = customer_id
9377 
    self.limit = limit
9378 
 
9379 
  def read(self, iprot):
9380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9382 
      return
9383 
    iprot.readStructBegin()
9384 
    while True:
9385 
      (fname, ftype, fid) = iprot.readFieldBegin()
9386 
      if ftype == TType.STOP:
9387 
        break
9388 
      if fid == 1:
9389 
        if ftype == TType.I64:
9390 
          self.customer_id = iprot.readI64();
9391 
        else:
9392 
          iprot.skip(ftype)
9393 
      elif fid == 2:
9394 
        if ftype == TType.I64:
9395 
          self.limit = iprot.readI64();
9396 
        else:
9397 
          iprot.skip(ftype)
9398 
      else:
9399 
        iprot.skip(ftype)
9400 
      iprot.readFieldEnd()
9401 
    iprot.readStructEnd()
9402 
 
9403 
  def write(self, oprot):
9404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9406 
      return
9407 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 9408 
    if self.customer_id is not None:
1382 varun.gupt 9409 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9410 
      oprot.writeI64(self.customer_id)
9411 
      oprot.writeFieldEnd()
3431 rajveer 9412 
    if self.limit is not None:
1382 varun.gupt 9413 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9414 
      oprot.writeI64(self.limit)
9415 
      oprot.writeFieldEnd()
9416 
    oprot.writeFieldStop()
9417 
    oprot.writeStructEnd()
9418 
 
3431 rajveer 9419 
  def validate(self):
9420 
    return
9421 
 
9422 
 
1382 varun.gupt 9423 
  def __repr__(self):
9424 
    L = ['%s=%r' % (key, value)
9425 
      for key, value in self.__dict__.iteritems()]
9426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9427 
 
9428 
  def __eq__(self, other):
9429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9430 
 
9431 
  def __ne__(self, other):
9432 
    return not (self == other)
9433 
 
9434 
class getReturnableOrdersForCustomer_result:
9435 
  """
9436 
  Attributes:
9437 
   - success
9438 
   - ex
9439 
  """
9440 
 
9441 
  thrift_spec = (
9442 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9443 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9444 
  )
9445 
 
9446 
  def __init__(self, success=None, ex=None,):
9447 
    self.success = success
9448 
    self.ex = ex
9449 
 
9450 
  def read(self, iprot):
9451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9453 
      return
9454 
    iprot.readStructBegin()
9455 
    while True:
9456 
      (fname, ftype, fid) = iprot.readFieldBegin()
9457 
      if ftype == TType.STOP:
9458 
        break
9459 
      if fid == 0:
9460 
        if ftype == TType.LIST:
9461 
          self.success = []
5031 varun.gupt 9462 
          (_etype129, _size126) = iprot.readListBegin()
9463 
          for _i130 in xrange(_size126):
9464 
            _elem131 = iprot.readI64();
9465 
            self.success.append(_elem131)
1382 varun.gupt 9466 
          iprot.readListEnd()
9467 
        else:
9468 
          iprot.skip(ftype)
9469 
      elif fid == 1:
9470 
        if ftype == TType.STRUCT:
9471 
          self.ex = TransactionServiceException()
9472 
          self.ex.read(iprot)
9473 
        else:
9474 
          iprot.skip(ftype)
9475 
      else:
9476 
        iprot.skip(ftype)
9477 
      iprot.readFieldEnd()
9478 
    iprot.readStructEnd()
9479 
 
9480 
  def write(self, oprot):
9481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9483 
      return
9484 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 9485 
    if self.success is not None:
1382 varun.gupt 9486 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9487 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 9488 
      for iter132 in self.success:
9489 
        oprot.writeI64(iter132)
1382 varun.gupt 9490 
      oprot.writeListEnd()
9491 
      oprot.writeFieldEnd()
3431 rajveer 9492 
    if self.ex is not None:
1382 varun.gupt 9493 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9494 
      self.ex.write(oprot)
9495 
      oprot.writeFieldEnd()
9496 
    oprot.writeFieldStop()
9497 
    oprot.writeStructEnd()
9498 
 
3431 rajveer 9499 
  def validate(self):
9500 
    return
9501 
 
9502 
 
1382 varun.gupt 9503 
  def __repr__(self):
9504 
    L = ['%s=%r' % (key, value)
9505 
      for key, value in self.__dict__.iteritems()]
9506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9507 
 
9508 
  def __eq__(self, other):
9509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9510 
 
9511 
  def __ne__(self, other):
9512 
    return not (self == other)
9513 
 
9514 
class getCancellableOrdersForCustomer_args:
9515 
  """
9516 
  Attributes:
9517 
   - customer_id
9518 
   - limit
9519 
  """
9520 
 
9521 
  thrift_spec = (
9522 
    None, # 0
9523 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9524 
    (2, TType.I64, 'limit', None, None, ), # 2
9525 
  )
9526 
 
9527 
  def __init__(self, customer_id=None, limit=None,):
9528 
    self.customer_id = customer_id
9529 
    self.limit = limit
9530 
 
9531 
  def read(self, iprot):
9532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9534 
      return
9535 
    iprot.readStructBegin()
9536 
    while True:
9537 
      (fname, ftype, fid) = iprot.readFieldBegin()
9538 
      if ftype == TType.STOP:
9539 
        break
9540 
      if fid == 1:
9541 
        if ftype == TType.I64:
9542 
          self.customer_id = iprot.readI64();
9543 
        else:
9544 
          iprot.skip(ftype)
9545 
      elif fid == 2:
9546 
        if ftype == TType.I64:
9547 
          self.limit = iprot.readI64();
9548 
        else:
9549 
          iprot.skip(ftype)
9550 
      else:
9551 
        iprot.skip(ftype)
9552 
      iprot.readFieldEnd()
9553 
    iprot.readStructEnd()
9554 
 
9555 
  def write(self, oprot):
9556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9558 
      return
9559 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 9560 
    if self.customer_id is not None:
1382 varun.gupt 9561 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9562 
      oprot.writeI64(self.customer_id)
9563 
      oprot.writeFieldEnd()
3431 rajveer 9564 
    if self.limit is not None:
1382 varun.gupt 9565 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9566 
      oprot.writeI64(self.limit)
9567 
      oprot.writeFieldEnd()
9568 
    oprot.writeFieldStop()
9569 
    oprot.writeStructEnd()
9570 
 
3431 rajveer 9571 
  def validate(self):
9572 
    return
9573 
 
9574 
 
1382 varun.gupt 9575 
  def __repr__(self):
9576 
    L = ['%s=%r' % (key, value)
9577 
      for key, value in self.__dict__.iteritems()]
9578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9579 
 
9580 
  def __eq__(self, other):
9581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9582 
 
9583 
  def __ne__(self, other):
9584 
    return not (self == other)
9585 
 
9586 
class getCancellableOrdersForCustomer_result:
9587 
  """
9588 
  Attributes:
9589 
   - success
9590 
   - ex
9591 
  """
9592 
 
9593 
  thrift_spec = (
9594 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9595 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9596 
  )
9597 
 
9598 
  def __init__(self, success=None, ex=None,):
9599 
    self.success = success
9600 
    self.ex = ex
9601 
 
9602 
  def read(self, iprot):
9603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9605 
      return
9606 
    iprot.readStructBegin()
9607 
    while True:
9608 
      (fname, ftype, fid) = iprot.readFieldBegin()
9609 
      if ftype == TType.STOP:
9610 
        break
9611 
      if fid == 0:
9612 
        if ftype == TType.LIST:
9613 
          self.success = []
5031 varun.gupt 9614 
          (_etype136, _size133) = iprot.readListBegin()
9615 
          for _i137 in xrange(_size133):
9616 
            _elem138 = iprot.readI64();
9617 
            self.success.append(_elem138)
1382 varun.gupt 9618 
          iprot.readListEnd()
9619 
        else:
9620 
          iprot.skip(ftype)
9621 
      elif fid == 1:
9622 
        if ftype == TType.STRUCT:
9623 
          self.ex = TransactionServiceException()
9624 
          self.ex.read(iprot)
9625 
        else:
9626 
          iprot.skip(ftype)
9627 
      else:
9628 
        iprot.skip(ftype)
9629 
      iprot.readFieldEnd()
9630 
    iprot.readStructEnd()
9631 
 
9632 
  def write(self, oprot):
9633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9635 
      return
9636 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 9637 
    if self.success is not None:
1382 varun.gupt 9638 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9639 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 9640 
      for iter139 in self.success:
9641 
        oprot.writeI64(iter139)
1382 varun.gupt 9642 
      oprot.writeListEnd()
9643 
      oprot.writeFieldEnd()
3431 rajveer 9644 
    if self.ex is not None:
1382 varun.gupt 9645 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9646 
      self.ex.write(oprot)
9647 
      oprot.writeFieldEnd()
9648 
    oprot.writeFieldStop()
9649 
    oprot.writeStructEnd()
9650 
 
3431 rajveer 9651 
  def validate(self):
9652 
    return
9653 
 
9654 
 
1382 varun.gupt 9655 
  def __repr__(self):
9656 
    L = ['%s=%r' % (key, value)
9657 
      for key, value in self.__dict__.iteritems()]
9658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9659 
 
9660 
  def __eq__(self, other):
9661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9662 
 
9663 
  def __ne__(self, other):
9664 
    return not (self == other)
9665 
 
483 rajveer 9666 
class changeOrderStatus_args:
94 ashish 9667 
  """
9668 
  Attributes:
483 rajveer 9669 
   - orderId
9670 
   - status
9671 
   - description
94 ashish 9672 
  """
9673 
 
9674 
  thrift_spec = (
9675 
    None, # 0
483 rajveer 9676 
    (1, TType.I64, 'orderId', None, None, ), # 1
9677 
    (2, TType.I32, 'status', None, None, ), # 2
9678 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9679 
  )
9680 
 
483 rajveer 9681 
  def __init__(self, orderId=None, status=None, description=None,):
9682 
    self.orderId = orderId
9683 
    self.status = status
9684 
    self.description = description
94 ashish 9685 
 
9686 
  def read(self, iprot):
9687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9689 
      return
9690 
    iprot.readStructBegin()
9691 
    while True:
9692 
      (fname, ftype, fid) = iprot.readFieldBegin()
9693 
      if ftype == TType.STOP:
9694 
        break
9695 
      if fid == 1:
9696 
        if ftype == TType.I64:
483 rajveer 9697 
          self.orderId = iprot.readI64();
94 ashish 9698 
        else:
9699 
          iprot.skip(ftype)
9700 
      elif fid == 2:
483 rajveer 9701 
        if ftype == TType.I32:
9702 
          self.status = iprot.readI32();
94 ashish 9703 
        else:
9704 
          iprot.skip(ftype)
483 rajveer 9705 
      elif fid == 3:
9706 
        if ftype == TType.STRING:
9707 
          self.description = iprot.readString();
9708 
        else:
9709 
          iprot.skip(ftype)
94 ashish 9710 
      else:
9711 
        iprot.skip(ftype)
9712 
      iprot.readFieldEnd()
9713 
    iprot.readStructEnd()
9714 
 
9715 
  def write(self, oprot):
9716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9718 
      return
483 rajveer 9719 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 9720 
    if self.orderId is not None:
483 rajveer 9721 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9722 
      oprot.writeI64(self.orderId)
94 ashish 9723 
      oprot.writeFieldEnd()
3431 rajveer 9724 
    if self.status is not None:
483 rajveer 9725 
      oprot.writeFieldBegin('status', TType.I32, 2)
9726 
      oprot.writeI32(self.status)
94 ashish 9727 
      oprot.writeFieldEnd()
3431 rajveer 9728 
    if self.description is not None:
483 rajveer 9729 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9730 
      oprot.writeString(self.description)
9731 
      oprot.writeFieldEnd()
94 ashish 9732 
    oprot.writeFieldStop()
9733 
    oprot.writeStructEnd()
9734 
 
3431 rajveer 9735 
  def validate(self):
9736 
    return
9737 
 
9738 
 
94 ashish 9739 
  def __repr__(self):
9740 
    L = ['%s=%r' % (key, value)
9741 
      for key, value in self.__dict__.iteritems()]
9742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9743 
 
9744 
  def __eq__(self, other):
9745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9746 
 
9747 
  def __ne__(self, other):
9748 
    return not (self == other)
9749 
 
483 rajveer 9750 
class changeOrderStatus_result:
94 ashish 9751 
  """
9752 
  Attributes:
9753 
   - success
9754 
   - ex
9755 
  """
9756 
 
9757 
  thrift_spec = (
9758 
    (0, TType.BOOL, 'success', None, None, ), # 0
9759 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9760 
  )
9761 
 
9762 
  def __init__(self, success=None, ex=None,):
9763 
    self.success = success
9764 
    self.ex = ex
9765 
 
9766 
  def read(self, iprot):
9767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9769 
      return
9770 
    iprot.readStructBegin()
9771 
    while True:
9772 
      (fname, ftype, fid) = iprot.readFieldBegin()
9773 
      if ftype == TType.STOP:
9774 
        break
9775 
      if fid == 0:
9776 
        if ftype == TType.BOOL:
9777 
          self.success = iprot.readBool();
9778 
        else:
9779 
          iprot.skip(ftype)
9780 
      elif fid == 1:
9781 
        if ftype == TType.STRUCT:
9782 
          self.ex = TransactionServiceException()
9783 
          self.ex.read(iprot)
9784 
        else:
9785 
          iprot.skip(ftype)
9786 
      else:
9787 
        iprot.skip(ftype)
9788 
      iprot.readFieldEnd()
9789 
    iprot.readStructEnd()
9790 
 
9791 
  def write(self, oprot):
9792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9794 
      return
483 rajveer 9795 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 9796 
    if self.success is not None:
94 ashish 9797 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9798 
      oprot.writeBool(self.success)
9799 
      oprot.writeFieldEnd()
3431 rajveer 9800 
    if self.ex is not None:
94 ashish 9801 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9802 
      self.ex.write(oprot)
9803 
      oprot.writeFieldEnd()
9804 
    oprot.writeFieldStop()
9805 
    oprot.writeStructEnd()
9806 
 
3431 rajveer 9807 
  def validate(self):
9808 
    return
9809 
 
9810 
 
94 ashish 9811 
  def __repr__(self):
9812 
    L = ['%s=%r' % (key, value)
9813 
      for key, value in self.__dict__.iteritems()]
9814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9815 
 
9816 
  def __eq__(self, other):
9817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9818 
 
9819 
  def __ne__(self, other):
9820 
    return not (self == other)
9821 
 
3064 chandransh 9822 
class getOrdersForTransaction_args:
494 rajveer 9823 
  """
9824 
  Attributes:
3064 chandransh 9825 
   - transactionId
9826 
   - customerId
494 rajveer 9827 
  """
9828 
 
9829 
  thrift_spec = (
9830 
    None, # 0
3064 chandransh 9831 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9832 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 9833 
  )
9834 
 
3064 chandransh 9835 
  def __init__(self, transactionId=None, customerId=None,):
9836 
    self.transactionId = transactionId
9837 
    self.customerId = customerId
494 rajveer 9838 
 
9839 
  def read(self, iprot):
9840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9842 
      return
9843 
    iprot.readStructBegin()
9844 
    while True:
9845 
      (fname, ftype, fid) = iprot.readFieldBegin()
9846 
      if ftype == TType.STOP:
9847 
        break
9848 
      if fid == 1:
9849 
        if ftype == TType.I64:
3064 chandransh 9850 
          self.transactionId = iprot.readI64();
494 rajveer 9851 
        else:
9852 
          iprot.skip(ftype)
9853 
      elif fid == 2:
3064 chandransh 9854 
        if ftype == TType.I64:
9855 
          self.customerId = iprot.readI64();
494 rajveer 9856 
        else:
9857 
          iprot.skip(ftype)
9858 
      else:
9859 
        iprot.skip(ftype)
9860 
      iprot.readFieldEnd()
9861 
    iprot.readStructEnd()
9862 
 
9863 
  def write(self, oprot):
9864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9866 
      return
3064 chandransh 9867 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 9868 
    if self.transactionId is not None:
3064 chandransh 9869 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9870 
      oprot.writeI64(self.transactionId)
494 rajveer 9871 
      oprot.writeFieldEnd()
3431 rajveer 9872 
    if self.customerId is not None:
3064 chandransh 9873 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
9874 
      oprot.writeI64(self.customerId)
494 rajveer 9875 
      oprot.writeFieldEnd()
9876 
    oprot.writeFieldStop()
9877 
    oprot.writeStructEnd()
9878 
 
3431 rajveer 9879 
  def validate(self):
9880 
    return
9881 
 
9882 
 
494 rajveer 9883 
  def __repr__(self):
9884 
    L = ['%s=%r' % (key, value)
9885 
      for key, value in self.__dict__.iteritems()]
9886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9887 
 
9888 
  def __eq__(self, other):
9889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9890 
 
9891 
  def __ne__(self, other):
9892 
    return not (self == other)
9893 
 
3064 chandransh 9894 
class getOrdersForTransaction_result:
494 rajveer 9895 
  """
9896 
  Attributes:
9897 
   - success
9898 
   - ex
9899 
  """
9900 
 
9901 
  thrift_spec = (
3064 chandransh 9902 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 9903 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9904 
  )
9905 
 
9906 
  def __init__(self, success=None, ex=None,):
9907 
    self.success = success
9908 
    self.ex = ex
9909 
 
9910 
  def read(self, iprot):
9911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9913 
      return
9914 
    iprot.readStructBegin()
9915 
    while True:
9916 
      (fname, ftype, fid) = iprot.readFieldBegin()
9917 
      if ftype == TType.STOP:
9918 
        break
9919 
      if fid == 0:
3064 chandransh 9920 
        if ftype == TType.LIST:
9921 
          self.success = []
5031 varun.gupt 9922 
          (_etype143, _size140) = iprot.readListBegin()
9923 
          for _i144 in xrange(_size140):
9924 
            _elem145 = Order()
9925 
            _elem145.read(iprot)
9926 
            self.success.append(_elem145)
3064 chandransh 9927 
          iprot.readListEnd()
494 rajveer 9928 
        else:
9929 
          iprot.skip(ftype)
9930 
      elif fid == 1:
9931 
        if ftype == TType.STRUCT:
9932 
          self.ex = TransactionServiceException()
9933 
          self.ex.read(iprot)
9934 
        else:
9935 
          iprot.skip(ftype)
9936 
      else:
9937 
        iprot.skip(ftype)
9938 
      iprot.readFieldEnd()
9939 
    iprot.readStructEnd()
9940 
 
9941 
  def write(self, oprot):
9942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9944 
      return
3064 chandransh 9945 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 9946 
    if self.success is not None:
3064 chandransh 9947 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9948 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9949 
      for iter146 in self.success:
9950 
        iter146.write(oprot)
3064 chandransh 9951 
      oprot.writeListEnd()
494 rajveer 9952 
      oprot.writeFieldEnd()
3431 rajveer 9953 
    if self.ex is not None:
494 rajveer 9954 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9955 
      self.ex.write(oprot)
9956 
      oprot.writeFieldEnd()
9957 
    oprot.writeFieldStop()
9958 
    oprot.writeStructEnd()
9959 
 
3431 rajveer 9960 
  def validate(self):
9961 
    return
9962 
 
9963 
 
494 rajveer 9964 
  def __repr__(self):
9965 
    L = ['%s=%r' % (key, value)
9966 
      for key, value in self.__dict__.iteritems()]
9967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9968 
 
9969 
  def __eq__(self, other):
9970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9971 
 
9972 
  def __ne__(self, other):
9973 
    return not (self == other)
9974 
 
3064 chandransh 9975 
class getOrdersForCustomer_args:
1149 chandransh 9976 
  """
9977 
  Attributes:
3064 chandransh 9978 
   - customerId
9979 
   - from_date
9980 
   - to_date
9981 
   - statuses
1149 chandransh 9982 
  """
9983 
 
9984 
  thrift_spec = (
9985 
    None, # 0
3064 chandransh 9986 
    (1, TType.I64, 'customerId', None, None, ), # 1
9987 
    (2, TType.I64, 'from_date', None, None, ), # 2
9988 
    (3, TType.I64, 'to_date', None, None, ), # 3
9989 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9990 
  )
9991 
 
3064 chandransh 9992 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9993 
    self.customerId = customerId
9994 
    self.from_date = from_date
9995 
    self.to_date = to_date
9996 
    self.statuses = statuses
1149 chandransh 9997 
 
9998 
  def read(self, iprot):
9999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10001 
      return
10002 
    iprot.readStructBegin()
10003 
    while True:
10004 
      (fname, ftype, fid) = iprot.readFieldBegin()
10005 
      if ftype == TType.STOP:
10006 
        break
10007 
      if fid == 1:
10008 
        if ftype == TType.I64:
3064 chandransh 10009 
          self.customerId = iprot.readI64();
1149 chandransh 10010 
        else:
10011 
          iprot.skip(ftype)
10012 
      elif fid == 2:
10013 
        if ftype == TType.I64:
3064 chandransh 10014 
          self.from_date = iprot.readI64();
1149 chandransh 10015 
        else:
10016 
          iprot.skip(ftype)
2783 chandransh 10017 
      elif fid == 3:
10018 
        if ftype == TType.I64:
3064 chandransh 10019 
          self.to_date = iprot.readI64();
2783 chandransh 10020 
        else:
10021 
          iprot.skip(ftype)
10022 
      elif fid == 4:
3064 chandransh 10023 
        if ftype == TType.LIST:
10024 
          self.statuses = []
5031 varun.gupt 10025 
          (_etype150, _size147) = iprot.readListBegin()
10026 
          for _i151 in xrange(_size147):
10027 
            _elem152 = iprot.readI32();
10028 
            self.statuses.append(_elem152)
3064 chandransh 10029 
          iprot.readListEnd()
2783 chandransh 10030 
        else:
10031 
          iprot.skip(ftype)
1149 chandransh 10032 
      else:
10033 
        iprot.skip(ftype)
10034 
      iprot.readFieldEnd()
10035 
    iprot.readStructEnd()
10036 
 
10037 
  def write(self, oprot):
10038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10040 
      return
3064 chandransh 10041 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 10042 
    if self.customerId is not None:
3064 chandransh 10043 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
10044 
      oprot.writeI64(self.customerId)
1149 chandransh 10045 
      oprot.writeFieldEnd()
3431 rajveer 10046 
    if self.from_date is not None:
3064 chandransh 10047 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10048 
      oprot.writeI64(self.from_date)
1149 chandransh 10049 
      oprot.writeFieldEnd()
3431 rajveer 10050 
    if self.to_date is not None:
3064 chandransh 10051 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10052 
      oprot.writeI64(self.to_date)
2783 chandransh 10053 
      oprot.writeFieldEnd()
3431 rajveer 10054 
    if self.statuses is not None:
3064 chandransh 10055 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
10056 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 10057 
      for iter153 in self.statuses:
10058 
        oprot.writeI32(iter153)
3064 chandransh 10059 
      oprot.writeListEnd()
2783 chandransh 10060 
      oprot.writeFieldEnd()
1149 chandransh 10061 
    oprot.writeFieldStop()
10062 
    oprot.writeStructEnd()
10063 
 
3431 rajveer 10064 
  def validate(self):
10065 
    return
10066 
 
10067 
 
1149 chandransh 10068 
  def __repr__(self):
10069 
    L = ['%s=%r' % (key, value)
10070 
      for key, value in self.__dict__.iteritems()]
10071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10072 
 
10073 
  def __eq__(self, other):
10074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10075 
 
10076 
  def __ne__(self, other):
10077 
    return not (self == other)
10078 
 
3064 chandransh 10079 
class getOrdersForCustomer_result:
1149 chandransh 10080 
  """
10081 
  Attributes:
10082 
   - success
10083 
   - ex
10084 
  """
10085 
 
10086 
  thrift_spec = (
3064 chandransh 10087 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 10088 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10089 
  )
10090 
 
10091 
  def __init__(self, success=None, ex=None,):
10092 
    self.success = success
10093 
    self.ex = ex
10094 
 
10095 
  def read(self, iprot):
10096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10098 
      return
10099 
    iprot.readStructBegin()
10100 
    while True:
10101 
      (fname, ftype, fid) = iprot.readFieldBegin()
10102 
      if ftype == TType.STOP:
10103 
        break
10104 
      if fid == 0:
3064 chandransh 10105 
        if ftype == TType.LIST:
10106 
          self.success = []
5031 varun.gupt 10107 
          (_etype157, _size154) = iprot.readListBegin()
10108 
          for _i158 in xrange(_size154):
10109 
            _elem159 = Order()
10110 
            _elem159.read(iprot)
10111 
            self.success.append(_elem159)
3064 chandransh 10112 
          iprot.readListEnd()
1149 chandransh 10113 
        else:
10114 
          iprot.skip(ftype)
10115 
      elif fid == 1:
10116 
        if ftype == TType.STRUCT:
10117 
          self.ex = TransactionServiceException()
10118 
          self.ex.read(iprot)
10119 
        else:
10120 
          iprot.skip(ftype)
10121 
      else:
10122 
        iprot.skip(ftype)
10123 
      iprot.readFieldEnd()
10124 
    iprot.readStructEnd()
10125 
 
10126 
  def write(self, oprot):
10127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10129 
      return
3064 chandransh 10130 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 10131 
    if self.success is not None:
3064 chandransh 10132 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10133 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10134 
      for iter160 in self.success:
10135 
        iter160.write(oprot)
3064 chandransh 10136 
      oprot.writeListEnd()
1149 chandransh 10137 
      oprot.writeFieldEnd()
3431 rajveer 10138 
    if self.ex is not None:
1149 chandransh 10139 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10140 
      self.ex.write(oprot)
10141 
      oprot.writeFieldEnd()
10142 
    oprot.writeFieldStop()
10143 
    oprot.writeStructEnd()
10144 
 
3431 rajveer 10145 
  def validate(self):
10146 
    return
10147 
 
10148 
 
1149 chandransh 10149 
  def __repr__(self):
10150 
    L = ['%s=%r' % (key, value)
10151 
      for key, value in self.__dict__.iteritems()]
10152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10153 
 
10154 
  def __eq__(self, other):
10155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10156 
 
10157 
  def __ne__(self, other):
10158 
    return not (self == other)
10159 
 
3064 chandransh 10160 
class createOrder_args:
921 rajveer 10161 
  """
10162 
  Attributes:
3064 chandransh 10163 
   - order
921 rajveer 10164 
  """
10165 
 
10166 
  thrift_spec = (
10167 
    None, # 0
3064 chandransh 10168 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 10169 
  )
10170 
 
3064 chandransh 10171 
  def __init__(self, order=None,):
10172 
    self.order = order
921 rajveer 10173 
 
10174 
  def read(self, iprot):
10175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10177 
      return
10178 
    iprot.readStructBegin()
10179 
    while True:
10180 
      (fname, ftype, fid) = iprot.readFieldBegin()
10181 
      if ftype == TType.STOP:
10182 
        break
10183 
      if fid == 1:
3064 chandransh 10184 
        if ftype == TType.STRUCT:
10185 
          self.order = Order()
10186 
          self.order.read(iprot)
921 rajveer 10187 
        else:
10188 
          iprot.skip(ftype)
10189 
      else:
10190 
        iprot.skip(ftype)
10191 
      iprot.readFieldEnd()
10192 
    iprot.readStructEnd()
10193 
 
10194 
  def write(self, oprot):
10195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10197 
      return
3064 chandransh 10198 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 10199 
    if self.order is not None:
3064 chandransh 10200 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
10201 
      self.order.write(oprot)
921 rajveer 10202 
      oprot.writeFieldEnd()
10203 
    oprot.writeFieldStop()
10204 
    oprot.writeStructEnd()
10205 
 
3431 rajveer 10206 
  def validate(self):
10207 
    return
10208 
 
10209 
 
921 rajveer 10210 
  def __repr__(self):
10211 
    L = ['%s=%r' % (key, value)
10212 
      for key, value in self.__dict__.iteritems()]
10213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10214 
 
10215 
  def __eq__(self, other):
10216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10217 
 
10218 
  def __ne__(self, other):
10219 
    return not (self == other)
10220 
 
3064 chandransh 10221 
class createOrder_result:
921 rajveer 10222 
  """
10223 
  Attributes:
10224 
   - success
10225 
   - ex
10226 
  """
10227 
 
10228 
  thrift_spec = (
3064 chandransh 10229 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 10230 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10231 
  )
10232 
 
10233 
  def __init__(self, success=None, ex=None,):
10234 
    self.success = success
10235 
    self.ex = ex
10236 
 
10237 
  def read(self, iprot):
10238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10240 
      return
10241 
    iprot.readStructBegin()
10242 
    while True:
10243 
      (fname, ftype, fid) = iprot.readFieldBegin()
10244 
      if ftype == TType.STOP:
10245 
        break
10246 
      if fid == 0:
3064 chandransh 10247 
        if ftype == TType.I64:
10248 
          self.success = iprot.readI64();
921 rajveer 10249 
        else:
10250 
          iprot.skip(ftype)
10251 
      elif fid == 1:
10252 
        if ftype == TType.STRUCT:
10253 
          self.ex = TransactionServiceException()
10254 
          self.ex.read(iprot)
10255 
        else:
10256 
          iprot.skip(ftype)
10257 
      else:
10258 
        iprot.skip(ftype)
10259 
      iprot.readFieldEnd()
10260 
    iprot.readStructEnd()
10261 
 
10262 
  def write(self, oprot):
10263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10265 
      return
3064 chandransh 10266 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 10267 
    if self.success is not None:
3064 chandransh 10268 
      oprot.writeFieldBegin('success', TType.I64, 0)
10269 
      oprot.writeI64(self.success)
921 rajveer 10270 
      oprot.writeFieldEnd()
3431 rajveer 10271 
    if self.ex is not None:
921 rajveer 10272 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10273 
      self.ex.write(oprot)
10274 
      oprot.writeFieldEnd()
10275 
    oprot.writeFieldStop()
10276 
    oprot.writeStructEnd()
10277 
 
3431 rajveer 10278 
  def validate(self):
10279 
    return
10280 
 
10281 
 
921 rajveer 10282 
  def __repr__(self):
10283 
    L = ['%s=%r' % (key, value)
10284 
      for key, value in self.__dict__.iteritems()]
10285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10286 
 
10287 
  def __eq__(self, other):
10288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10289 
 
10290 
  def __ne__(self, other):
10291 
    return not (self == other)
10292 
 
3064 chandransh 10293 
class getOrder_args:
921 rajveer 10294 
  """
10295 
  Attributes:
3064 chandransh 10296 
   - id
921 rajveer 10297 
  """
10298 
 
10299 
  thrift_spec = (
10300 
    None, # 0
3064 chandransh 10301 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 10302 
  )
10303 
 
3064 chandransh 10304 
  def __init__(self, id=None,):
10305 
    self.id = id
921 rajveer 10306 
 
10307 
  def read(self, iprot):
10308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10310 
      return
10311 
    iprot.readStructBegin()
10312 
    while True:
10313 
      (fname, ftype, fid) = iprot.readFieldBegin()
10314 
      if ftype == TType.STOP:
10315 
        break
10316 
      if fid == 1:
10317 
        if ftype == TType.I64:
3064 chandransh 10318 
          self.id = iprot.readI64();
921 rajveer 10319 
        else:
10320 
          iprot.skip(ftype)
10321 
      else:
10322 
        iprot.skip(ftype)
10323 
      iprot.readFieldEnd()
10324 
    iprot.readStructEnd()
10325 
 
10326 
  def write(self, oprot):
10327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10329 
      return
3064 chandransh 10330 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 10331 
    if self.id is not None:
3064 chandransh 10332 
      oprot.writeFieldBegin('id', TType.I64, 1)
10333 
      oprot.writeI64(self.id)
921 rajveer 10334 
      oprot.writeFieldEnd()
10335 
    oprot.writeFieldStop()
10336 
    oprot.writeStructEnd()
10337 
 
3431 rajveer 10338 
  def validate(self):
10339 
    return
10340 
 
10341 
 
921 rajveer 10342 
  def __repr__(self):
10343 
    L = ['%s=%r' % (key, value)
10344 
      for key, value in self.__dict__.iteritems()]
10345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10346 
 
10347 
  def __eq__(self, other):
10348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10349 
 
10350 
  def __ne__(self, other):
10351 
    return not (self == other)
10352 
 
3064 chandransh 10353 
class getOrder_result:
921 rajveer 10354 
  """
10355 
  Attributes:
10356 
   - success
10357 
   - ex
10358 
  """
10359 
 
10360 
  thrift_spec = (
3064 chandransh 10361 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 10362 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10363 
  )
10364 
 
10365 
  def __init__(self, success=None, ex=None,):
10366 
    self.success = success
10367 
    self.ex = ex
10368 
 
10369 
  def read(self, iprot):
10370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10372 
      return
10373 
    iprot.readStructBegin()
10374 
    while True:
10375 
      (fname, ftype, fid) = iprot.readFieldBegin()
10376 
      if ftype == TType.STOP:
10377 
        break
10378 
      if fid == 0:
3064 chandransh 10379 
        if ftype == TType.STRUCT:
10380 
          self.success = Order()
10381 
          self.success.read(iprot)
921 rajveer 10382 
        else:
10383 
          iprot.skip(ftype)
10384 
      elif fid == 1:
10385 
        if ftype == TType.STRUCT:
10386 
          self.ex = TransactionServiceException()
10387 
          self.ex.read(iprot)
10388 
        else:
10389 
          iprot.skip(ftype)
10390 
      else:
10391 
        iprot.skip(ftype)
10392 
      iprot.readFieldEnd()
10393 
    iprot.readStructEnd()
10394 
 
10395 
  def write(self, oprot):
10396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10398 
      return
3064 chandransh 10399 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 10400 
    if self.success is not None:
3064 chandransh 10401 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10402 
      self.success.write(oprot)
921 rajveer 10403 
      oprot.writeFieldEnd()
3431 rajveer 10404 
    if self.ex is not None:
921 rajveer 10405 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10406 
      self.ex.write(oprot)
10407 
      oprot.writeFieldEnd()
10408 
    oprot.writeFieldStop()
10409 
    oprot.writeStructEnd()
10410 
 
3431 rajveer 10411 
  def validate(self):
10412 
    return
10413 
 
10414 
 
921 rajveer 10415 
  def __repr__(self):
10416 
    L = ['%s=%r' % (key, value)
10417 
      for key, value in self.__dict__.iteritems()]
10418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10419 
 
10420 
  def __eq__(self, other):
10421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10422 
 
10423 
  def __ne__(self, other):
10424 
    return not (self == other)
10425 
 
3064 chandransh 10426 
class getLineItemsForOrder_args:
94 ashish 10427 
  """
10428 
  Attributes:
3064 chandransh 10429 
   - orderId
94 ashish 10430 
  """
10431 
 
10432 
  thrift_spec = (
10433 
    None, # 0
3064 chandransh 10434 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 10435 
  )
10436 
 
3064 chandransh 10437 
  def __init__(self, orderId=None,):
10438 
    self.orderId = orderId
94 ashish 10439 
 
10440 
  def read(self, iprot):
10441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10443 
      return
10444 
    iprot.readStructBegin()
10445 
    while True:
10446 
      (fname, ftype, fid) = iprot.readFieldBegin()
10447 
      if ftype == TType.STOP:
10448 
        break
10449 
      if fid == 1:
10450 
        if ftype == TType.I64:
3064 chandransh 10451 
          self.orderId = iprot.readI64();
94 ashish 10452 
        else:
10453 
          iprot.skip(ftype)
10454 
      else:
10455 
        iprot.skip(ftype)
10456 
      iprot.readFieldEnd()
10457 
    iprot.readStructEnd()
10458 
 
10459 
  def write(self, oprot):
10460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10462 
      return
3064 chandransh 10463 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 10464 
    if self.orderId is not None:
3064 chandransh 10465 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10466 
      oprot.writeI64(self.orderId)
94 ashish 10467 
      oprot.writeFieldEnd()
10468 
    oprot.writeFieldStop()
10469 
    oprot.writeStructEnd()
10470 
 
3431 rajveer 10471 
  def validate(self):
10472 
    return
10473 
 
10474 
 
94 ashish 10475 
  def __repr__(self):
10476 
    L = ['%s=%r' % (key, value)
10477 
      for key, value in self.__dict__.iteritems()]
10478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10479 
 
10480 
  def __eq__(self, other):
10481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10482 
 
10483 
  def __ne__(self, other):
10484 
    return not (self == other)
10485 
 
3064 chandransh 10486 
class getLineItemsForOrder_result:
94 ashish 10487 
  """
10488 
  Attributes:
10489 
   - success
10490 
   - ex
10491 
  """
10492 
 
10493 
  thrift_spec = (
3064 chandransh 10494 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 10495 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10496 
  )
10497 
 
10498 
  def __init__(self, success=None, ex=None,):
10499 
    self.success = success
10500 
    self.ex = ex
10501 
 
10502 
  def read(self, iprot):
10503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10505 
      return
10506 
    iprot.readStructBegin()
10507 
    while True:
10508 
      (fname, ftype, fid) = iprot.readFieldBegin()
10509 
      if ftype == TType.STOP:
10510 
        break
10511 
      if fid == 0:
483 rajveer 10512 
        if ftype == TType.LIST:
10513 
          self.success = []
5031 varun.gupt 10514 
          (_etype164, _size161) = iprot.readListBegin()
10515 
          for _i165 in xrange(_size161):
10516 
            _elem166 = LineItem()
10517 
            _elem166.read(iprot)
10518 
            self.success.append(_elem166)
483 rajveer 10519 
          iprot.readListEnd()
94 ashish 10520 
        else:
10521 
          iprot.skip(ftype)
10522 
      elif fid == 1:
10523 
        if ftype == TType.STRUCT:
10524 
          self.ex = TransactionServiceException()
10525 
          self.ex.read(iprot)
10526 
        else:
10527 
          iprot.skip(ftype)
10528 
      else:
10529 
        iprot.skip(ftype)
10530 
      iprot.readFieldEnd()
10531 
    iprot.readStructEnd()
10532 
 
10533 
  def write(self, oprot):
10534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10536 
      return
3064 chandransh 10537 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 10538 
    if self.success is not None:
483 rajveer 10539 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10540 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10541 
      for iter167 in self.success:
10542 
        iter167.write(oprot)
483 rajveer 10543 
      oprot.writeListEnd()
94 ashish 10544 
      oprot.writeFieldEnd()
3431 rajveer 10545 
    if self.ex is not None:
94 ashish 10546 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10547 
      self.ex.write(oprot)
10548 
      oprot.writeFieldEnd()
10549 
    oprot.writeFieldStop()
10550 
    oprot.writeStructEnd()
10551 
 
3431 rajveer 10552 
  def validate(self):
10553 
    return
10554 
 
10555 
 
94 ashish 10556 
  def __repr__(self):
10557 
    L = ['%s=%r' % (key, value)
10558 
      for key, value in self.__dict__.iteritems()]
10559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10560 
 
10561 
  def __eq__(self, other):
10562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10563 
 
10564 
  def __ne__(self, other):
10565 
    return not (self == other)
10566 
 
4999 phani.kuma 10567 
class getOrderList_args:
10568 
  """
10569 
  Attributes:
10570 
   - order_ids
10571 
  """
10572 
 
10573 
  thrift_spec = (
10574 
    None, # 0
10575 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10576 
  )
10577 
 
10578 
  def __init__(self, order_ids=None,):
10579 
    self.order_ids = order_ids
10580 
 
10581 
  def read(self, iprot):
10582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10584 
      return
10585 
    iprot.readStructBegin()
10586 
    while True:
10587 
      (fname, ftype, fid) = iprot.readFieldBegin()
10588 
      if ftype == TType.STOP:
10589 
        break
10590 
      if fid == 1:
10591 
        if ftype == TType.LIST:
10592 
          self.order_ids = []
5031 varun.gupt 10593 
          (_etype171, _size168) = iprot.readListBegin()
10594 
          for _i172 in xrange(_size168):
10595 
            _elem173 = iprot.readI64();
10596 
            self.order_ids.append(_elem173)
4999 phani.kuma 10597 
          iprot.readListEnd()
10598 
        else:
10599 
          iprot.skip(ftype)
10600 
      else:
10601 
        iprot.skip(ftype)
10602 
      iprot.readFieldEnd()
10603 
    iprot.readStructEnd()
10604 
 
10605 
  def write(self, oprot):
10606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10608 
      return
10609 
    oprot.writeStructBegin('getOrderList_args')
10610 
    if self.order_ids is not None:
10611 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10612 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 10613 
      for iter174 in self.order_ids:
10614 
        oprot.writeI64(iter174)
4999 phani.kuma 10615 
      oprot.writeListEnd()
10616 
      oprot.writeFieldEnd()
10617 
    oprot.writeFieldStop()
10618 
    oprot.writeStructEnd()
10619 
 
10620 
  def validate(self):
10621 
    return
10622 
 
10623 
 
10624 
  def __repr__(self):
10625 
    L = ['%s=%r' % (key, value)
10626 
      for key, value in self.__dict__.iteritems()]
10627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10628 
 
10629 
  def __eq__(self, other):
10630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10631 
 
10632 
  def __ne__(self, other):
10633 
    return not (self == other)
10634 
 
10635 
class getOrderList_result:
10636 
  """
10637 
  Attributes:
10638 
   - success
10639 
  """
10640 
 
10641 
  thrift_spec = (
10642 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10643 
  )
10644 
 
10645 
  def __init__(self, success=None,):
10646 
    self.success = success
10647 
 
10648 
  def read(self, iprot):
10649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10651 
      return
10652 
    iprot.readStructBegin()
10653 
    while True:
10654 
      (fname, ftype, fid) = iprot.readFieldBegin()
10655 
      if ftype == TType.STOP:
10656 
        break
10657 
      if fid == 0:
10658 
        if ftype == TType.LIST:
10659 
          self.success = []
5031 varun.gupt 10660 
          (_etype178, _size175) = iprot.readListBegin()
10661 
          for _i179 in xrange(_size175):
10662 
            _elem180 = Order()
10663 
            _elem180.read(iprot)
10664 
            self.success.append(_elem180)
4999 phani.kuma 10665 
          iprot.readListEnd()
10666 
        else:
10667 
          iprot.skip(ftype)
10668 
      else:
10669 
        iprot.skip(ftype)
10670 
      iprot.readFieldEnd()
10671 
    iprot.readStructEnd()
10672 
 
10673 
  def write(self, oprot):
10674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10676 
      return
10677 
    oprot.writeStructBegin('getOrderList_result')
10678 
    if self.success is not None:
10679 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10680 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10681 
      for iter181 in self.success:
10682 
        iter181.write(oprot)
4999 phani.kuma 10683 
      oprot.writeListEnd()
10684 
      oprot.writeFieldEnd()
10685 
    oprot.writeFieldStop()
10686 
    oprot.writeStructEnd()
10687 
 
10688 
  def validate(self):
10689 
    return
10690 
 
10691 
 
10692 
  def __repr__(self):
10693 
    L = ['%s=%r' % (key, value)
10694 
      for key, value in self.__dict__.iteritems()]
10695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10696 
 
10697 
  def __eq__(self, other):
10698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10699 
 
10700 
  def __ne__(self, other):
10701 
    return not (self == other)
10702 
 
5386 phani.kuma 10703 
class getOrderListForVendor_args:
10704 
  """
10705 
  Attributes:
10706 
   - order_ids
10707 
   - vendorId
10708 
  """
10709 
 
10710 
  thrift_spec = (
10711 
    None, # 0
10712 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10713 
    (2, TType.I64, 'vendorId', None, None, ), # 2
10714 
  )
10715 
 
10716 
  def __init__(self, order_ids=None, vendorId=None,):
10717 
    self.order_ids = order_ids
10718 
    self.vendorId = vendorId
10719 
 
10720 
  def read(self, iprot):
10721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10723 
      return
10724 
    iprot.readStructBegin()
10725 
    while True:
10726 
      (fname, ftype, fid) = iprot.readFieldBegin()
10727 
      if ftype == TType.STOP:
10728 
        break
10729 
      if fid == 1:
10730 
        if ftype == TType.LIST:
10731 
          self.order_ids = []
10732 
          (_etype185, _size182) = iprot.readListBegin()
10733 
          for _i186 in xrange(_size182):
10734 
            _elem187 = iprot.readI64();
10735 
            self.order_ids.append(_elem187)
10736 
          iprot.readListEnd()
10737 
        else:
10738 
          iprot.skip(ftype)
10739 
      elif fid == 2:
10740 
        if ftype == TType.I64:
10741 
          self.vendorId = iprot.readI64();
10742 
        else:
10743 
          iprot.skip(ftype)
10744 
      else:
10745 
        iprot.skip(ftype)
10746 
      iprot.readFieldEnd()
10747 
    iprot.readStructEnd()
10748 
 
10749 
  def write(self, oprot):
10750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10752 
      return
10753 
    oprot.writeStructBegin('getOrderListForVendor_args')
10754 
    if self.order_ids is not None:
10755 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10756 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
10757 
      for iter188 in self.order_ids:
10758 
        oprot.writeI64(iter188)
10759 
      oprot.writeListEnd()
10760 
      oprot.writeFieldEnd()
10761 
    if self.vendorId is not None:
10762 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
10763 
      oprot.writeI64(self.vendorId)
10764 
      oprot.writeFieldEnd()
10765 
    oprot.writeFieldStop()
10766 
    oprot.writeStructEnd()
10767 
 
10768 
  def validate(self):
10769 
    return
10770 
 
10771 
 
10772 
  def __repr__(self):
10773 
    L = ['%s=%r' % (key, value)
10774 
      for key, value in self.__dict__.iteritems()]
10775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10776 
 
10777 
  def __eq__(self, other):
10778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10779 
 
10780 
  def __ne__(self, other):
10781 
    return not (self == other)
10782 
 
10783 
class getOrderListForVendor_result:
10784 
  """
10785 
  Attributes:
10786 
   - success
10787 
  """
10788 
 
10789 
  thrift_spec = (
10790 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10791 
  )
10792 
 
10793 
  def __init__(self, success=None,):
10794 
    self.success = success
10795 
 
10796 
  def read(self, iprot):
10797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10799 
      return
10800 
    iprot.readStructBegin()
10801 
    while True:
10802 
      (fname, ftype, fid) = iprot.readFieldBegin()
10803 
      if ftype == TType.STOP:
10804 
        break
10805 
      if fid == 0:
10806 
        if ftype == TType.LIST:
10807 
          self.success = []
10808 
          (_etype192, _size189) = iprot.readListBegin()
10809 
          for _i193 in xrange(_size189):
10810 
            _elem194 = Order()
10811 
            _elem194.read(iprot)
10812 
            self.success.append(_elem194)
10813 
          iprot.readListEnd()
10814 
        else:
10815 
          iprot.skip(ftype)
10816 
      else:
10817 
        iprot.skip(ftype)
10818 
      iprot.readFieldEnd()
10819 
    iprot.readStructEnd()
10820 
 
10821 
  def write(self, oprot):
10822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10824 
      return
10825 
    oprot.writeStructBegin('getOrderListForVendor_result')
10826 
    if self.success is not None:
10827 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10828 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10829 
      for iter195 in self.success:
10830 
        iter195.write(oprot)
10831 
      oprot.writeListEnd()
10832 
      oprot.writeFieldEnd()
10833 
    oprot.writeFieldStop()
10834 
    oprot.writeStructEnd()
10835 
 
10836 
  def validate(self):
10837 
    return
10838 
 
10839 
 
10840 
  def __repr__(self):
10841 
    L = ['%s=%r' % (key, value)
10842 
      for key, value in self.__dict__.iteritems()]
10843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10844 
 
10845 
  def __eq__(self, other):
10846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10847 
 
10848 
  def __ne__(self, other):
10849 
    return not (self == other)
10850 
 
3064 chandransh 10851 
class getOrderForCustomer_args:
94 ashish 10852 
  """
10853 
  Attributes:
3064 chandransh 10854 
   - orderId
483 rajveer 10855 
   - customerId
94 ashish 10856 
  """
10857 
 
10858 
  thrift_spec = (
10859 
    None, # 0
3064 chandransh 10860 
    (1, TType.I64, 'orderId', None, None, ), # 1
10861 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 10862 
  )
10863 
 
3064 chandransh 10864 
  def __init__(self, orderId=None, customerId=None,):
10865 
    self.orderId = orderId
483 rajveer 10866 
    self.customerId = customerId
94 ashish 10867 
 
10868 
  def read(self, iprot):
10869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10871 
      return
10872 
    iprot.readStructBegin()
10873 
    while True:
10874 
      (fname, ftype, fid) = iprot.readFieldBegin()
10875 
      if ftype == TType.STOP:
10876 
        break
10877 
      if fid == 1:
10878 
        if ftype == TType.I64:
3064 chandransh 10879 
          self.orderId = iprot.readI64();
94 ashish 10880 
        else:
10881 
          iprot.skip(ftype)
10882 
      elif fid == 2:
10883 
        if ftype == TType.I64:
3064 chandransh 10884 
          self.customerId = iprot.readI64();
94 ashish 10885 
        else:
10886 
          iprot.skip(ftype)
10887 
      else:
10888 
        iprot.skip(ftype)
10889 
      iprot.readFieldEnd()
10890 
    iprot.readStructEnd()
10891 
 
10892 
  def write(self, oprot):
10893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10895 
      return
3064 chandransh 10896 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 10897 
    if self.orderId is not None:
3064 chandransh 10898 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10899 
      oprot.writeI64(self.orderId)
10900 
      oprot.writeFieldEnd()
3431 rajveer 10901 
    if self.customerId is not None:
3064 chandransh 10902 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 10903 
      oprot.writeI64(self.customerId)
94 ashish 10904 
      oprot.writeFieldEnd()
10905 
    oprot.writeFieldStop()
10906 
    oprot.writeStructEnd()
10907 
 
3431 rajveer 10908 
  def validate(self):
10909 
    return
10910 
 
10911 
 
94 ashish 10912 
  def __repr__(self):
10913 
    L = ['%s=%r' % (key, value)
10914 
      for key, value in self.__dict__.iteritems()]
10915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10916 
 
10917 
  def __eq__(self, other):
10918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10919 
 
10920 
  def __ne__(self, other):
10921 
    return not (self == other)
10922 
 
3064 chandransh 10923 
class getOrderForCustomer_result:
94 ashish 10924 
  """
10925 
  Attributes:
10926 
   - success
10927 
   - ex
10928 
  """
10929 
 
10930 
  thrift_spec = (
3064 chandransh 10931 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 10932 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10933 
  )
10934 
 
10935 
  def __init__(self, success=None, ex=None,):
10936 
    self.success = success
10937 
    self.ex = ex
10938 
 
10939 
  def read(self, iprot):
10940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10942 
      return
10943 
    iprot.readStructBegin()
10944 
    while True:
10945 
      (fname, ftype, fid) = iprot.readFieldBegin()
10946 
      if ftype == TType.STOP:
10947 
        break
10948 
      if fid == 0:
3064 chandransh 10949 
        if ftype == TType.STRUCT:
10950 
          self.success = Order()
10951 
          self.success.read(iprot)
94 ashish 10952 
        else:
10953 
          iprot.skip(ftype)
10954 
      elif fid == 1:
10955 
        if ftype == TType.STRUCT:
10956 
          self.ex = TransactionServiceException()
10957 
          self.ex.read(iprot)
10958 
        else:
10959 
          iprot.skip(ftype)
10960 
      else:
10961 
        iprot.skip(ftype)
10962 
      iprot.readFieldEnd()
10963 
    iprot.readStructEnd()
10964 
 
10965 
  def write(self, oprot):
10966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10968 
      return
3064 chandransh 10969 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 10970 
    if self.success is not None:
3064 chandransh 10971 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10972 
      self.success.write(oprot)
94 ashish 10973 
      oprot.writeFieldEnd()
3431 rajveer 10974 
    if self.ex is not None:
94 ashish 10975 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10976 
      self.ex.write(oprot)
10977 
      oprot.writeFieldEnd()
10978 
    oprot.writeFieldStop()
10979 
    oprot.writeStructEnd()
10980 
 
3431 rajveer 10981 
  def validate(self):
10982 
    return
10983 
 
10984 
 
94 ashish 10985 
  def __repr__(self):
10986 
    L = ['%s=%r' % (key, value)
10987 
      for key, value in self.__dict__.iteritems()]
10988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10989 
 
10990 
  def __eq__(self, other):
10991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10992 
 
10993 
  def __ne__(self, other):
10994 
    return not (self == other)
10995 
 
3064 chandransh 10996 
class getAlerts_args:
94 ashish 10997 
  """
10998 
  Attributes:
4394 rajveer 10999 
   - type
4444 rajveer 11000 
   - warehouseId
4394 rajveer 11001 
   - status
11002 
   - timestamp
94 ashish 11003 
  """
11004 
 
11005 
  thrift_spec = (
11006 
    None, # 0
4394 rajveer 11007 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11008 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11009 
    (3, TType.I64, 'status', None, None, ), # 3
11010 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 11011 
  )
11012 
 
4444 rajveer 11013 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 11014 
    self.type = type
4444 rajveer 11015 
    self.warehouseId = warehouseId
4394 rajveer 11016 
    self.status = status
11017 
    self.timestamp = timestamp
94 ashish 11018 
 
11019 
  def read(self, iprot):
11020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11022 
      return
11023 
    iprot.readStructBegin()
11024 
    while True:
11025 
      (fname, ftype, fid) = iprot.readFieldBegin()
11026 
      if ftype == TType.STOP:
11027 
        break
11028 
      if fid == 1:
3064 chandransh 11029 
        if ftype == TType.I64:
4394 rajveer 11030 
          self.type = iprot.readI64();
94 ashish 11031 
        else:
11032 
          iprot.skip(ftype)
3064 chandransh 11033 
      elif fid == 2:
4394 rajveer 11034 
        if ftype == TType.I64:
4444 rajveer 11035 
          self.warehouseId = iprot.readI64();
3064 chandransh 11036 
        else:
11037 
          iprot.skip(ftype)
4394 rajveer 11038 
      elif fid == 3:
11039 
        if ftype == TType.I64:
4444 rajveer 11040 
          self.status = iprot.readI64();
11041 
        else:
11042 
          iprot.skip(ftype)
11043 
      elif fid == 4:
11044 
        if ftype == TType.I64:
4394 rajveer 11045 
          self.timestamp = iprot.readI64();
11046 
        else:
11047 
          iprot.skip(ftype)
94 ashish 11048 
      else:
11049 
        iprot.skip(ftype)
11050 
      iprot.readFieldEnd()
11051 
    iprot.readStructEnd()
11052 
 
11053 
  def write(self, oprot):
11054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11056 
      return
3064 chandransh 11057 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 11058 
    if self.type is not None:
11059 
      oprot.writeFieldBegin('type', TType.I64, 1)
11060 
      oprot.writeI64(self.type)
94 ashish 11061 
      oprot.writeFieldEnd()
4444 rajveer 11062 
    if self.warehouseId is not None:
11063 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11064 
      oprot.writeI64(self.warehouseId)
11065 
      oprot.writeFieldEnd()
4394 rajveer 11066 
    if self.status is not None:
4444 rajveer 11067 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 11068 
      oprot.writeI64(self.status)
3064 chandransh 11069 
      oprot.writeFieldEnd()
4394 rajveer 11070 
    if self.timestamp is not None:
4444 rajveer 11071 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 11072 
      oprot.writeI64(self.timestamp)
11073 
      oprot.writeFieldEnd()
94 ashish 11074 
    oprot.writeFieldStop()
11075 
    oprot.writeStructEnd()
11076 
 
3431 rajveer 11077 
  def validate(self):
11078 
    return
11079 
 
11080 
 
94 ashish 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 
 
3064 chandransh 11092 
class getAlerts_result:
94 ashish 11093 
  """
11094 
  Attributes:
11095 
   - success
11096 
  """
11097 
 
11098 
  thrift_spec = (
3064 chandransh 11099 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 11100 
  )
11101 
 
3064 chandransh 11102 
  def __init__(self, success=None,):
94 ashish 11103 
    self.success = success
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
11114 
      if fid == 0:
3064 chandransh 11115 
        if ftype == TType.LIST:
11116 
          self.success = []
5386 phani.kuma 11117 
          (_etype199, _size196) = iprot.readListBegin()
11118 
          for _i200 in xrange(_size196):
11119 
            _elem201 = Alert()
11120 
            _elem201.read(iprot)
11121 
            self.success.append(_elem201)
3064 chandransh 11122 
          iprot.readListEnd()
94 ashish 11123 
        else:
11124 
          iprot.skip(ftype)
11125 
      else:
11126 
        iprot.skip(ftype)
11127 
      iprot.readFieldEnd()
11128 
    iprot.readStructEnd()
11129 
 
11130 
  def write(self, oprot):
11131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11133 
      return
3064 chandransh 11134 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 11135 
    if self.success is not None:
3064 chandransh 11136 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11137 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11138 
      for iter202 in self.success:
11139 
        iter202.write(oprot)
3064 chandransh 11140 
      oprot.writeListEnd()
94 ashish 11141 
      oprot.writeFieldEnd()
11142 
    oprot.writeFieldStop()
11143 
    oprot.writeStructEnd()
11144 
 
3431 rajveer 11145 
  def validate(self):
11146 
    return
11147 
 
11148 
 
94 ashish 11149 
  def __repr__(self):
11150 
    L = ['%s=%r' % (key, value)
11151 
      for key, value in self.__dict__.iteritems()]
11152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11153 
 
11154 
  def __eq__(self, other):
11155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11156 
 
11157 
  def __ne__(self, other):
11158 
    return not (self == other)
11159 
 
4394 rajveer 11160 
class addAlert_args:
94 ashish 11161 
  """
11162 
  Attributes:
3064 chandransh 11163 
   - type
4444 rajveer 11164 
   - warehouseId
4394 rajveer 11165 
   - description
94 ashish 11166 
  """
11167 
 
11168 
  thrift_spec = (
11169 
    None, # 0
4394 rajveer 11170 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11171 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11172 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11173 
  )
11174 
 
4444 rajveer 11175 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 11176 
    self.type = type
4444 rajveer 11177 
    self.warehouseId = warehouseId
4394 rajveer 11178 
    self.description = description
94 ashish 11179 
 
11180 
  def read(self, iprot):
11181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11183 
      return
11184 
    iprot.readStructBegin()
11185 
    while True:
11186 
      (fname, ftype, fid) = iprot.readFieldBegin()
11187 
      if ftype == TType.STOP:
11188 
        break
11189 
      if fid == 1:
11190 
        if ftype == TType.I64:
4394 rajveer 11191 
          self.type = iprot.readI64();
94 ashish 11192 
        else:
11193 
          iprot.skip(ftype)
3064 chandransh 11194 
      elif fid == 2:
4444 rajveer 11195 
        if ftype == TType.I64:
11196 
          self.warehouseId = iprot.readI64();
11197 
        else:
11198 
          iprot.skip(ftype)
11199 
      elif fid == 3:
3064 chandransh 11200 
        if ftype == TType.STRING:
4394 rajveer 11201 
          self.description = iprot.readString();
3064 chandransh 11202 
        else:
11203 
          iprot.skip(ftype)
94 ashish 11204 
      else:
11205 
        iprot.skip(ftype)
11206 
      iprot.readFieldEnd()
11207 
    iprot.readStructEnd()
11208 
 
11209 
  def write(self, oprot):
11210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11212 
      return
4394 rajveer 11213 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 11214 
    if self.type is not None:
4394 rajveer 11215 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 11216 
      oprot.writeI64(self.type)
11217 
      oprot.writeFieldEnd()
4444 rajveer 11218 
    if self.warehouseId is not None:
11219 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11220 
      oprot.writeI64(self.warehouseId)
11221 
      oprot.writeFieldEnd()
4394 rajveer 11222 
    if self.description is not None:
4444 rajveer 11223 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 11224 
      oprot.writeString(self.description)
3064 chandransh 11225 
      oprot.writeFieldEnd()
94 ashish 11226 
    oprot.writeFieldStop()
11227 
    oprot.writeStructEnd()
11228 
 
3431 rajveer 11229 
  def validate(self):
11230 
    return
11231 
 
11232 
 
94 ashish 11233 
  def __repr__(self):
11234 
    L = ['%s=%r' % (key, value)
11235 
      for key, value in self.__dict__.iteritems()]
11236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11237 
 
11238 
  def __eq__(self, other):
11239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11240 
 
11241 
  def __ne__(self, other):
11242 
    return not (self == other)
11243 
 
4394 rajveer 11244 
class addAlert_result:
3064 chandransh 11245 
 
11246 
  thrift_spec = (
11247 
  )
11248 
 
11249 
  def read(self, iprot):
11250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11252 
      return
11253 
    iprot.readStructBegin()
11254 
    while True:
11255 
      (fname, ftype, fid) = iprot.readFieldBegin()
11256 
      if ftype == TType.STOP:
11257 
        break
11258 
      else:
11259 
        iprot.skip(ftype)
11260 
      iprot.readFieldEnd()
11261 
    iprot.readStructEnd()
11262 
 
11263 
  def write(self, oprot):
11264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11266 
      return
4394 rajveer 11267 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 11268 
    oprot.writeFieldStop()
11269 
    oprot.writeStructEnd()
11270 
 
3431 rajveer 11271 
  def validate(self):
11272 
    return
11273 
 
11274 
 
3064 chandransh 11275 
  def __repr__(self):
11276 
    L = ['%s=%r' % (key, value)
11277 
      for key, value in self.__dict__.iteritems()]
11278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11279 
 
11280 
  def __eq__(self, other):
11281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11282 
 
11283 
  def __ne__(self, other):
11284 
    return not (self == other)
11285 
 
4444 rajveer 11286 
class markAlertsAsSeen_args:
11287 
  """
11288 
  Attributes:
11289 
   - warehouseId
11290 
  """
11291 
 
11292 
  thrift_spec = (
11293 
    None, # 0
11294 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11295 
  )
11296 
 
11297 
  def __init__(self, warehouseId=None,):
11298 
    self.warehouseId = warehouseId
11299 
 
11300 
  def read(self, iprot):
11301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11303 
      return
11304 
    iprot.readStructBegin()
11305 
    while True:
11306 
      (fname, ftype, fid) = iprot.readFieldBegin()
11307 
      if ftype == TType.STOP:
11308 
        break
11309 
      if fid == 1:
11310 
        if ftype == TType.I64:
11311 
          self.warehouseId = iprot.readI64();
11312 
        else:
11313 
          iprot.skip(ftype)
11314 
      else:
11315 
        iprot.skip(ftype)
11316 
      iprot.readFieldEnd()
11317 
    iprot.readStructEnd()
11318 
 
11319 
  def write(self, oprot):
11320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11322 
      return
11323 
    oprot.writeStructBegin('markAlertsAsSeen_args')
11324 
    if self.warehouseId is not None:
11325 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11326 
      oprot.writeI64(self.warehouseId)
11327 
      oprot.writeFieldEnd()
11328 
    oprot.writeFieldStop()
11329 
    oprot.writeStructEnd()
11330 
 
11331 
  def validate(self):
11332 
    return
11333 
 
11334 
 
11335 
  def __repr__(self):
11336 
    L = ['%s=%r' % (key, value)
11337 
      for key, value in self.__dict__.iteritems()]
11338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11339 
 
11340 
  def __eq__(self, other):
11341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11342 
 
11343 
  def __ne__(self, other):
11344 
    return not (self == other)
11345 
 
11346 
class markAlertsAsSeen_result:
11347 
 
11348 
  thrift_spec = (
11349 
  )
11350 
 
11351 
  def read(self, iprot):
11352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11354 
      return
11355 
    iprot.readStructBegin()
11356 
    while True:
11357 
      (fname, ftype, fid) = iprot.readFieldBegin()
11358 
      if ftype == TType.STOP:
11359 
        break
11360 
      else:
11361 
        iprot.skip(ftype)
11362 
      iprot.readFieldEnd()
11363 
    iprot.readStructEnd()
11364 
 
11365 
  def write(self, oprot):
11366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11368 
      return
11369 
    oprot.writeStructBegin('markAlertsAsSeen_result')
11370 
    oprot.writeFieldStop()
11371 
    oprot.writeStructEnd()
11372 
 
11373 
  def validate(self):
11374 
    return
11375 
 
11376 
 
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 
 
3064 chandransh 11388 
class getValidOrderCount_args:
11389 
 
11390 
  thrift_spec = (
11391 
  )
11392 
 
11393 
  def read(self, iprot):
11394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11396 
      return
11397 
    iprot.readStructBegin()
11398 
    while True:
11399 
      (fname, ftype, fid) = iprot.readFieldBegin()
11400 
      if ftype == TType.STOP:
11401 
        break
11402 
      else:
11403 
        iprot.skip(ftype)
11404 
      iprot.readFieldEnd()
11405 
    iprot.readStructEnd()
11406 
 
11407 
  def write(self, oprot):
11408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11410 
      return
11411 
    oprot.writeStructBegin('getValidOrderCount_args')
11412 
    oprot.writeFieldStop()
11413 
    oprot.writeStructEnd()
11414 
 
3431 rajveer 11415 
  def validate(self):
11416 
    return
11417 
 
11418 
 
3064 chandransh 11419 
  def __repr__(self):
11420 
    L = ['%s=%r' % (key, value)
11421 
      for key, value in self.__dict__.iteritems()]
11422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11423 
 
11424 
  def __eq__(self, other):
11425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11426 
 
11427 
  def __ne__(self, other):
11428 
    return not (self == other)
11429 
 
11430 
class getValidOrderCount_result:
94 ashish 11431 
  """
11432 
  Attributes:
11433 
   - success
11434 
  """
11435 
 
11436 
  thrift_spec = (
3064 chandransh 11437 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11438 
  )
11439 
 
3064 chandransh 11440 
  def __init__(self, success=None,):
94 ashish 11441 
    self.success = success
11442 
 
11443 
  def read(self, iprot):
11444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11446 
      return
11447 
    iprot.readStructBegin()
11448 
    while True:
11449 
      (fname, ftype, fid) = iprot.readFieldBegin()
11450 
      if ftype == TType.STOP:
11451 
        break
11452 
      if fid == 0:
3064 chandransh 11453 
        if ftype == TType.I64:
11454 
          self.success = iprot.readI64();
94 ashish 11455 
        else:
11456 
          iprot.skip(ftype)
11457 
      else:
11458 
        iprot.skip(ftype)
11459 
      iprot.readFieldEnd()
11460 
    iprot.readStructEnd()
11461 
 
11462 
  def write(self, oprot):
11463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11465 
      return
3064 chandransh 11466 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 11467 
    if self.success is not None:
3064 chandransh 11468 
      oprot.writeFieldBegin('success', TType.I64, 0)
11469 
      oprot.writeI64(self.success)
94 ashish 11470 
      oprot.writeFieldEnd()
11471 
    oprot.writeFieldStop()
11472 
    oprot.writeStructEnd()
11473 
 
3431 rajveer 11474 
  def validate(self):
11475 
    return
11476 
 
11477 
 
94 ashish 11478 
  def __repr__(self):
11479 
    L = ['%s=%r' % (key, value)
11480 
      for key, value in self.__dict__.iteritems()]
11481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11482 
 
11483 
  def __eq__(self, other):
11484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11485 
 
11486 
  def __ne__(self, other):
11487 
    return not (self == other)
11488 
 
3064 chandransh 11489 
class getNoOfCustomersWithSuccessfulTransaction_args:
11490 
 
11491 
  thrift_spec = (
11492 
  )
11493 
 
11494 
  def read(self, iprot):
11495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11497 
      return
11498 
    iprot.readStructBegin()
11499 
    while True:
11500 
      (fname, ftype, fid) = iprot.readFieldBegin()
11501 
      if ftype == TType.STOP:
11502 
        break
11503 
      else:
11504 
        iprot.skip(ftype)
11505 
      iprot.readFieldEnd()
11506 
    iprot.readStructEnd()
11507 
 
11508 
  def write(self, oprot):
11509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11511 
      return
11512 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
11513 
    oprot.writeFieldStop()
11514 
    oprot.writeStructEnd()
11515 
 
3431 rajveer 11516 
  def validate(self):
11517 
    return
11518 
 
11519 
 
3064 chandransh 11520 
  def __repr__(self):
11521 
    L = ['%s=%r' % (key, value)
11522 
      for key, value in self.__dict__.iteritems()]
11523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11524 
 
11525 
  def __eq__(self, other):
11526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11527 
 
11528 
  def __ne__(self, other):
11529 
    return not (self == other)
11530 
 
11531 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 11532 
  """
11533 
  Attributes:
3064 chandransh 11534 
   - success
94 ashish 11535 
  """
11536 
 
11537 
  thrift_spec = (
3064 chandransh 11538 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11539 
  )
11540 
 
3064 chandransh 11541 
  def __init__(self, success=None,):
11542 
    self.success = success
94 ashish 11543 
 
11544 
  def read(self, iprot):
11545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11547 
      return
11548 
    iprot.readStructBegin()
11549 
    while True:
11550 
      (fname, ftype, fid) = iprot.readFieldBegin()
11551 
      if ftype == TType.STOP:
11552 
        break
3064 chandransh 11553 
      if fid == 0:
94 ashish 11554 
        if ftype == TType.I64:
3064 chandransh 11555 
          self.success = iprot.readI64();
94 ashish 11556 
        else:
11557 
          iprot.skip(ftype)
11558 
      else:
11559 
        iprot.skip(ftype)
11560 
      iprot.readFieldEnd()
11561 
    iprot.readStructEnd()
11562 
 
11563 
  def write(self, oprot):
11564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11566 
      return
3064 chandransh 11567 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 11568 
    if self.success is not None:
3064 chandransh 11569 
      oprot.writeFieldBegin('success', TType.I64, 0)
11570 
      oprot.writeI64(self.success)
94 ashish 11571 
      oprot.writeFieldEnd()
11572 
    oprot.writeFieldStop()
11573 
    oprot.writeStructEnd()
11574 
 
3431 rajveer 11575 
  def validate(self):
11576 
    return
11577 
 
11578 
 
94 ashish 11579 
  def __repr__(self):
11580 
    L = ['%s=%r' % (key, value)
11581 
      for key, value in self.__dict__.iteritems()]
11582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11583 
 
11584 
  def __eq__(self, other):
11585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11586 
 
11587 
  def __ne__(self, other):
11588 
    return not (self == other)
11589 
 
3064 chandransh 11590 
class getValidOrdersAmountRange_args:
11591 
 
11592 
  thrift_spec = (
11593 
  )
11594 
 
11595 
  def read(self, iprot):
11596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11598 
      return
11599 
    iprot.readStructBegin()
11600 
    while True:
11601 
      (fname, ftype, fid) = iprot.readFieldBegin()
11602 
      if ftype == TType.STOP:
11603 
        break
11604 
      else:
11605 
        iprot.skip(ftype)
11606 
      iprot.readFieldEnd()
11607 
    iprot.readStructEnd()
11608 
 
11609 
  def write(self, oprot):
11610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11612 
      return
11613 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
11614 
    oprot.writeFieldStop()
11615 
    oprot.writeStructEnd()
11616 
 
3431 rajveer 11617 
  def validate(self):
11618 
    return
11619 
 
11620 
 
3064 chandransh 11621 
  def __repr__(self):
11622 
    L = ['%s=%r' % (key, value)
11623 
      for key, value in self.__dict__.iteritems()]
11624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11625 
 
11626 
  def __eq__(self, other):
11627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11628 
 
11629 
  def __ne__(self, other):
11630 
    return not (self == other)
11631 
 
11632 
class getValidOrdersAmountRange_result:
94 ashish 11633 
  """
11634 
  Attributes:
11635 
   - success
11636 
  """
11637 
 
11638 
  thrift_spec = (
3064 chandransh 11639 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 11640 
  )
11641 
 
3064 chandransh 11642 
  def __init__(self, success=None,):
94 ashish 11643 
    self.success = success
11644 
 
11645 
  def read(self, iprot):
11646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11648 
      return
11649 
    iprot.readStructBegin()
11650 
    while True:
11651 
      (fname, ftype, fid) = iprot.readFieldBegin()
11652 
      if ftype == TType.STOP:
11653 
        break
11654 
      if fid == 0:
483 rajveer 11655 
        if ftype == TType.LIST:
11656 
          self.success = []
5386 phani.kuma 11657 
          (_etype206, _size203) = iprot.readListBegin()
11658 
          for _i207 in xrange(_size203):
11659 
            _elem208 = iprot.readDouble();
11660 
            self.success.append(_elem208)
483 rajveer 11661 
          iprot.readListEnd()
94 ashish 11662 
        else:
11663 
          iprot.skip(ftype)
11664 
      else:
11665 
        iprot.skip(ftype)
11666 
      iprot.readFieldEnd()
11667 
    iprot.readStructEnd()
11668 
 
11669 
  def write(self, oprot):
11670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11672 
      return
3064 chandransh 11673 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 11674 
    if self.success is not None:
483 rajveer 11675 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 11676 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5386 phani.kuma 11677 
      for iter209 in self.success:
11678 
        oprot.writeDouble(iter209)
483 rajveer 11679 
      oprot.writeListEnd()
94 ashish 11680 
      oprot.writeFieldEnd()
11681 
    oprot.writeFieldStop()
11682 
    oprot.writeStructEnd()
11683 
 
3431 rajveer 11684 
  def validate(self):
11685 
    return
11686 
 
11687 
 
94 ashish 11688 
  def __repr__(self):
11689 
    L = ['%s=%r' % (key, value)
11690 
      for key, value in self.__dict__.iteritems()]
11691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11692 
 
11693 
  def __eq__(self, other):
11694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11695 
 
11696 
  def __ne__(self, other):
11697 
    return not (self == other)
11698 
 
3064 chandransh 11699 
class getValidOrders_args:
1528 ankur.sing 11700 
  """
11701 
  Attributes:
3064 chandransh 11702 
   - limit
1528 ankur.sing 11703 
  """
11704 
 
11705 
  thrift_spec = (
11706 
    None, # 0
3064 chandransh 11707 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 11708 
  )
11709 
 
3064 chandransh 11710 
  def __init__(self, limit=None,):
11711 
    self.limit = limit
1528 ankur.sing 11712 
 
11713 
  def read(self, iprot):
11714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11716 
      return
11717 
    iprot.readStructBegin()
11718 
    while True:
11719 
      (fname, ftype, fid) = iprot.readFieldBegin()
11720 
      if ftype == TType.STOP:
11721 
        break
11722 
      if fid == 1:
11723 
        if ftype == TType.I64:
3064 chandransh 11724 
          self.limit = iprot.readI64();
1528 ankur.sing 11725 
        else:
11726 
          iprot.skip(ftype)
11727 
      else:
11728 
        iprot.skip(ftype)
11729 
      iprot.readFieldEnd()
11730 
    iprot.readStructEnd()
11731 
 
11732 
  def write(self, oprot):
11733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11735 
      return
3064 chandransh 11736 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 11737 
    if self.limit is not None:
3064 chandransh 11738 
      oprot.writeFieldBegin('limit', TType.I64, 1)
11739 
      oprot.writeI64(self.limit)
1528 ankur.sing 11740 
      oprot.writeFieldEnd()
11741 
    oprot.writeFieldStop()
11742 
    oprot.writeStructEnd()
11743 
 
3431 rajveer 11744 
  def validate(self):
11745 
    return
11746 
 
11747 
 
1528 ankur.sing 11748 
  def __repr__(self):
11749 
    L = ['%s=%r' % (key, value)
11750 
      for key, value in self.__dict__.iteritems()]
11751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11752 
 
11753 
  def __eq__(self, other):
11754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11755 
 
11756 
  def __ne__(self, other):
11757 
    return not (self == other)
11758 
 
3064 chandransh 11759 
class getValidOrders_result:
1528 ankur.sing 11760 
  """
11761 
  Attributes:
11762 
   - success
11763 
  """
11764 
 
11765 
  thrift_spec = (
3064 chandransh 11766 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 11767 
  )
11768 
 
3064 chandransh 11769 
  def __init__(self, success=None,):
1528 ankur.sing 11770 
    self.success = success
11771 
 
11772 
  def read(self, iprot):
11773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11775 
      return
11776 
    iprot.readStructBegin()
11777 
    while True:
11778 
      (fname, ftype, fid) = iprot.readFieldBegin()
11779 
      if ftype == TType.STOP:
11780 
        break
11781 
      if fid == 0:
3064 chandransh 11782 
        if ftype == TType.LIST:
11783 
          self.success = []
5386 phani.kuma 11784 
          (_etype213, _size210) = iprot.readListBegin()
11785 
          for _i214 in xrange(_size210):
11786 
            _elem215 = Order()
11787 
            _elem215.read(iprot)
11788 
            self.success.append(_elem215)
3064 chandransh 11789 
          iprot.readListEnd()
1528 ankur.sing 11790 
        else:
11791 
          iprot.skip(ftype)
11792 
      else:
11793 
        iprot.skip(ftype)
11794 
      iprot.readFieldEnd()
11795 
    iprot.readStructEnd()
11796 
 
11797 
  def write(self, oprot):
11798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11800 
      return
3064 chandransh 11801 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 11802 
    if self.success is not None:
3064 chandransh 11803 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11804 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11805 
      for iter216 in self.success:
11806 
        iter216.write(oprot)
3064 chandransh 11807 
      oprot.writeListEnd()
1528 ankur.sing 11808 
      oprot.writeFieldEnd()
11809 
    oprot.writeFieldStop()
11810 
    oprot.writeStructEnd()
11811 
 
3431 rajveer 11812 
  def validate(self):
11813 
    return
11814 
 
11815 
 
1528 ankur.sing 11816 
  def __repr__(self):
11817 
    L = ['%s=%r' % (key, value)
11818 
      for key, value in self.__dict__.iteritems()]
11819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11820 
 
11821 
  def __eq__(self, other):
11822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11823 
 
11824 
  def __ne__(self, other):
11825 
    return not (self == other)
11826 
 
1220 chandransh 11827 
class batchOrders_args:
11828 
  """
11829 
  Attributes:
11830 
   - warehouseId
11831 
  """
11832 
 
11833 
  thrift_spec = (
11834 
    None, # 0
11835 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11836 
  )
11837 
 
11838 
  def __init__(self, warehouseId=None,):
11839 
    self.warehouseId = warehouseId
11840 
 
11841 
  def read(self, iprot):
11842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11844 
      return
11845 
    iprot.readStructBegin()
11846 
    while True:
11847 
      (fname, ftype, fid) = iprot.readFieldBegin()
11848 
      if ftype == TType.STOP:
11849 
        break
11850 
      if fid == 1:
11851 
        if ftype == TType.I64:
11852 
          self.warehouseId = iprot.readI64();
11853 
        else:
11854 
          iprot.skip(ftype)
11855 
      else:
11856 
        iprot.skip(ftype)
11857 
      iprot.readFieldEnd()
11858 
    iprot.readStructEnd()
11859 
 
11860 
  def write(self, oprot):
11861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11863 
      return
11864 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 11865 
    if self.warehouseId is not None:
1220 chandransh 11866 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11867 
      oprot.writeI64(self.warehouseId)
11868 
      oprot.writeFieldEnd()
11869 
    oprot.writeFieldStop()
11870 
    oprot.writeStructEnd()
11871 
 
3431 rajveer 11872 
  def validate(self):
11873 
    return
11874 
 
11875 
 
1220 chandransh 11876 
  def __repr__(self):
11877 
    L = ['%s=%r' % (key, value)
11878 
      for key, value in self.__dict__.iteritems()]
11879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11880 
 
11881 
  def __eq__(self, other):
11882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11883 
 
11884 
  def __ne__(self, other):
11885 
    return not (self == other)
11886 
 
11887 
class batchOrders_result:
11888 
  """
11889 
  Attributes:
11890 
   - success
11891 
   - ex
11892 
  """
11893 
 
11894 
  thrift_spec = (
11895 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11896 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11897 
  )
11898 
 
11899 
  def __init__(self, success=None, ex=None,):
11900 
    self.success = success
11901 
    self.ex = ex
11902 
 
11903 
  def read(self, iprot):
11904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11906 
      return
11907 
    iprot.readStructBegin()
11908 
    while True:
11909 
      (fname, ftype, fid) = iprot.readFieldBegin()
11910 
      if ftype == TType.STOP:
11911 
        break
11912 
      if fid == 0:
11913 
        if ftype == TType.LIST:
11914 
          self.success = []
5386 phani.kuma 11915 
          (_etype220, _size217) = iprot.readListBegin()
11916 
          for _i221 in xrange(_size217):
11917 
            _elem222 = Order()
11918 
            _elem222.read(iprot)
11919 
            self.success.append(_elem222)
1220 chandransh 11920 
          iprot.readListEnd()
11921 
        else:
11922 
          iprot.skip(ftype)
11923 
      elif fid == 1:
11924 
        if ftype == TType.STRUCT:
11925 
          self.ex = TransactionServiceException()
11926 
          self.ex.read(iprot)
11927 
        else:
11928 
          iprot.skip(ftype)
11929 
      else:
11930 
        iprot.skip(ftype)
11931 
      iprot.readFieldEnd()
11932 
    iprot.readStructEnd()
11933 
 
11934 
  def write(self, oprot):
11935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11937 
      return
11938 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 11939 
    if self.success is not None:
1220 chandransh 11940 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11941 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11942 
      for iter223 in self.success:
11943 
        iter223.write(oprot)
1220 chandransh 11944 
      oprot.writeListEnd()
11945 
      oprot.writeFieldEnd()
3431 rajveer 11946 
    if self.ex is not None:
1220 chandransh 11947 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11948 
      self.ex.write(oprot)
11949 
      oprot.writeFieldEnd()
11950 
    oprot.writeFieldStop()
11951 
    oprot.writeStructEnd()
11952 
 
3431 rajveer 11953 
  def validate(self):
11954 
    return
11955 
 
11956 
 
1220 chandransh 11957 
  def __repr__(self):
11958 
    L = ['%s=%r' % (key, value)
11959 
      for key, value in self.__dict__.iteritems()]
11960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11961 
 
11962 
  def __eq__(self, other):
11963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11964 
 
11965 
  def __ne__(self, other):
11966 
    return not (self == other)
11967 
 
1208 chandransh 11968 
class markOrderAsOutOfStock_args:
11969 
  """
11970 
  Attributes:
11971 
   - orderId
11972 
  """
11973 
 
11974 
  thrift_spec = (
11975 
    None, # 0
11976 
    (1, TType.I64, 'orderId', None, None, ), # 1
11977 
  )
11978 
 
11979 
  def __init__(self, orderId=None,):
11980 
    self.orderId = orderId
11981 
 
11982 
  def read(self, iprot):
11983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11985 
      return
11986 
    iprot.readStructBegin()
11987 
    while True:
11988 
      (fname, ftype, fid) = iprot.readFieldBegin()
11989 
      if ftype == TType.STOP:
11990 
        break
11991 
      if fid == 1:
11992 
        if ftype == TType.I64:
11993 
          self.orderId = iprot.readI64();
11994 
        else:
11995 
          iprot.skip(ftype)
11996 
      else:
11997 
        iprot.skip(ftype)
11998 
      iprot.readFieldEnd()
11999 
    iprot.readStructEnd()
12000 
 
12001 
  def write(self, oprot):
12002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12004 
      return
12005 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 12006 
    if self.orderId is not None:
1208 chandransh 12007 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12008 
      oprot.writeI64(self.orderId)
12009 
      oprot.writeFieldEnd()
12010 
    oprot.writeFieldStop()
12011 
    oprot.writeStructEnd()
12012 
 
3431 rajveer 12013 
  def validate(self):
12014 
    return
12015 
 
12016 
 
1208 chandransh 12017 
  def __repr__(self):
12018 
    L = ['%s=%r' % (key, value)
12019 
      for key, value in self.__dict__.iteritems()]
12020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12021 
 
12022 
  def __eq__(self, other):
12023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12024 
 
12025 
  def __ne__(self, other):
12026 
    return not (self == other)
12027 
 
12028 
class markOrderAsOutOfStock_result:
12029 
  """
12030 
  Attributes:
12031 
   - success
12032 
   - ex
12033 
  """
12034 
 
12035 
  thrift_spec = (
12036 
    (0, TType.BOOL, 'success', None, None, ), # 0
12037 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12038 
  )
12039 
 
12040 
  def __init__(self, success=None, ex=None,):
12041 
    self.success = success
12042 
    self.ex = ex
12043 
 
12044 
  def read(self, iprot):
12045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12047 
      return
12048 
    iprot.readStructBegin()
12049 
    while True:
12050 
      (fname, ftype, fid) = iprot.readFieldBegin()
12051 
      if ftype == TType.STOP:
12052 
        break
12053 
      if fid == 0:
12054 
        if ftype == TType.BOOL:
12055 
          self.success = iprot.readBool();
12056 
        else:
12057 
          iprot.skip(ftype)
12058 
      elif fid == 1:
12059 
        if ftype == TType.STRUCT:
12060 
          self.ex = TransactionServiceException()
12061 
          self.ex.read(iprot)
12062 
        else:
12063 
          iprot.skip(ftype)
12064 
      else:
12065 
        iprot.skip(ftype)
12066 
      iprot.readFieldEnd()
12067 
    iprot.readStructEnd()
12068 
 
12069 
  def write(self, oprot):
12070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12072 
      return
12073 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 12074 
    if self.success is not None:
1208 chandransh 12075 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12076 
      oprot.writeBool(self.success)
12077 
      oprot.writeFieldEnd()
3431 rajveer 12078 
    if self.ex is not None:
1208 chandransh 12079 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12080 
      self.ex.write(oprot)
12081 
      oprot.writeFieldEnd()
12082 
    oprot.writeFieldStop()
12083 
    oprot.writeStructEnd()
12084 
 
3431 rajveer 12085 
  def validate(self):
12086 
    return
12087 
 
12088 
 
1208 chandransh 12089 
  def __repr__(self):
12090 
    L = ['%s=%r' % (key, value)
12091 
      for key, value in self.__dict__.iteritems()]
12092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12093 
 
12094 
  def __eq__(self, other):
12095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12096 
 
12097 
  def __ne__(self, other):
12098 
    return not (self == other)
12099 
 
3064 chandransh 12100 
class verifyOrder_args:
759 chandransh 12101 
  """
12102 
  Attributes:
3064 chandransh 12103 
   - orderId
759 chandransh 12104 
  """
12105 
 
12106 
  thrift_spec = (
12107 
    None, # 0
3064 chandransh 12108 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 12109 
  )
12110 
 
3064 chandransh 12111 
  def __init__(self, orderId=None,):
12112 
    self.orderId = orderId
759 chandransh 12113 
 
12114 
  def read(self, iprot):
12115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12117 
      return
12118 
    iprot.readStructBegin()
12119 
    while True:
12120 
      (fname, ftype, fid) = iprot.readFieldBegin()
12121 
      if ftype == TType.STOP:
12122 
        break
12123 
      if fid == 1:
12124 
        if ftype == TType.I64:
3064 chandransh 12125 
          self.orderId = iprot.readI64();
759 chandransh 12126 
        else:
12127 
          iprot.skip(ftype)
12128 
      else:
12129 
        iprot.skip(ftype)
12130 
      iprot.readFieldEnd()
12131 
    iprot.readStructEnd()
12132 
 
12133 
  def write(self, oprot):
12134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12136 
      return
3064 chandransh 12137 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 12138 
    if self.orderId is not None:
3064 chandransh 12139 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12140 
      oprot.writeI64(self.orderId)
759 chandransh 12141 
      oprot.writeFieldEnd()
12142 
    oprot.writeFieldStop()
12143 
    oprot.writeStructEnd()
12144 
 
3431 rajveer 12145 
  def validate(self):
12146 
    return
12147 
 
12148 
 
759 chandransh 12149 
  def __repr__(self):
12150 
    L = ['%s=%r' % (key, value)
12151 
      for key, value in self.__dict__.iteritems()]
12152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12153 
 
12154 
  def __eq__(self, other):
12155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12156 
 
12157 
  def __ne__(self, other):
12158 
    return not (self == other)
12159 
 
3064 chandransh 12160 
class verifyOrder_result:
759 chandransh 12161 
  """
12162 
  Attributes:
12163 
   - success
12164 
   - ex
12165 
  """
12166 
 
12167 
  thrift_spec = (
12168 
    (0, TType.BOOL, 'success', None, None, ), # 0
12169 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12170 
  )
12171 
 
12172 
  def __init__(self, success=None, ex=None,):
12173 
    self.success = success
12174 
    self.ex = ex
12175 
 
12176 
  def read(self, iprot):
12177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12179 
      return
12180 
    iprot.readStructBegin()
12181 
    while True:
12182 
      (fname, ftype, fid) = iprot.readFieldBegin()
12183 
      if ftype == TType.STOP:
12184 
        break
12185 
      if fid == 0:
12186 
        if ftype == TType.BOOL:
12187 
          self.success = iprot.readBool();
12188 
        else:
12189 
          iprot.skip(ftype)
12190 
      elif fid == 1:
12191 
        if ftype == TType.STRUCT:
12192 
          self.ex = TransactionServiceException()
12193 
          self.ex.read(iprot)
12194 
        else:
12195 
          iprot.skip(ftype)
12196 
      else:
12197 
        iprot.skip(ftype)
12198 
      iprot.readFieldEnd()
12199 
    iprot.readStructEnd()
12200 
 
12201 
  def write(self, oprot):
12202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12204 
      return
3064 chandransh 12205 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 12206 
    if self.success is not None:
759 chandransh 12207 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12208 
      oprot.writeBool(self.success)
12209 
      oprot.writeFieldEnd()
3431 rajveer 12210 
    if self.ex is not None:
759 chandransh 12211 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12212 
      self.ex.write(oprot)
12213 
      oprot.writeFieldEnd()
12214 
    oprot.writeFieldStop()
12215 
    oprot.writeStructEnd()
12216 
 
3431 rajveer 12217 
  def validate(self):
12218 
    return
12219 
 
12220 
 
759 chandransh 12221 
  def __repr__(self):
12222 
    L = ['%s=%r' % (key, value)
12223 
      for key, value in self.__dict__.iteritems()]
12224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12225 
 
12226 
  def __eq__(self, other):
12227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12228 
 
12229 
  def __ne__(self, other):
12230 
    return not (self == other)
12231 
 
3064 chandransh 12232 
class acceptOrder_args:
1113 chandransh 12233 
  """
12234 
  Attributes:
3064 chandransh 12235 
   - orderId
1113 chandransh 12236 
  """
12237 
 
12238 
  thrift_spec = (
12239 
    None, # 0
3064 chandransh 12240 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 12241 
  )
12242 
 
3064 chandransh 12243 
  def __init__(self, orderId=None,):
12244 
    self.orderId = orderId
1113 chandransh 12245 
 
12246 
  def read(self, iprot):
12247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12249 
      return
12250 
    iprot.readStructBegin()
12251 
    while True:
12252 
      (fname, ftype, fid) = iprot.readFieldBegin()
12253 
      if ftype == TType.STOP:
12254 
        break
12255 
      if fid == 1:
12256 
        if ftype == TType.I64:
3064 chandransh 12257 
          self.orderId = iprot.readI64();
1113 chandransh 12258 
        else:
12259 
          iprot.skip(ftype)
12260 
      else:
12261 
        iprot.skip(ftype)
12262 
      iprot.readFieldEnd()
12263 
    iprot.readStructEnd()
12264 
 
12265 
  def write(self, oprot):
12266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12268 
      return
3064 chandransh 12269 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 12270 
    if self.orderId is not None:
3064 chandransh 12271 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12272 
      oprot.writeI64(self.orderId)
1113 chandransh 12273 
      oprot.writeFieldEnd()
12274 
    oprot.writeFieldStop()
12275 
    oprot.writeStructEnd()
12276 
 
3431 rajveer 12277 
  def validate(self):
12278 
    return
12279 
 
12280 
 
1113 chandransh 12281 
  def __repr__(self):
12282 
    L = ['%s=%r' % (key, value)
12283 
      for key, value in self.__dict__.iteritems()]
12284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12285 
 
12286 
  def __eq__(self, other):
12287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12288 
 
12289 
  def __ne__(self, other):
12290 
    return not (self == other)
12291 
 
3064 chandransh 12292 
class acceptOrder_result:
1113 chandransh 12293 
  """
12294 
  Attributes:
12295 
   - success
12296 
   - ex
12297 
  """
12298 
 
12299 
  thrift_spec = (
3064 chandransh 12300 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 12301 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12302 
  )
12303 
 
12304 
  def __init__(self, success=None, ex=None,):
12305 
    self.success = success
12306 
    self.ex = ex
12307 
 
12308 
  def read(self, iprot):
12309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12311 
      return
12312 
    iprot.readStructBegin()
12313 
    while True:
12314 
      (fname, ftype, fid) = iprot.readFieldBegin()
12315 
      if ftype == TType.STOP:
12316 
        break
12317 
      if fid == 0:
3064 chandransh 12318 
        if ftype == TType.BOOL:
12319 
          self.success = iprot.readBool();
1113 chandransh 12320 
        else:
12321 
          iprot.skip(ftype)
12322 
      elif fid == 1:
12323 
        if ftype == TType.STRUCT:
12324 
          self.ex = TransactionServiceException()
12325 
          self.ex.read(iprot)
12326 
        else:
12327 
          iprot.skip(ftype)
12328 
      else:
12329 
        iprot.skip(ftype)
12330 
      iprot.readFieldEnd()
12331 
    iprot.readStructEnd()
12332 
 
12333 
  def write(self, oprot):
12334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12336 
      return
3064 chandransh 12337 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 12338 
    if self.success is not None:
3064 chandransh 12339 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12340 
      oprot.writeBool(self.success)
1113 chandransh 12341 
      oprot.writeFieldEnd()
3431 rajveer 12342 
    if self.ex is not None:
1113 chandransh 12343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12344 
      self.ex.write(oprot)
12345 
      oprot.writeFieldEnd()
12346 
    oprot.writeFieldStop()
12347 
    oprot.writeStructEnd()
12348 
 
3431 rajveer 12349 
  def validate(self):
12350 
    return
12351 
 
12352 
 
1113 chandransh 12353 
  def __repr__(self):
12354 
    L = ['%s=%r' % (key, value)
12355 
      for key, value in self.__dict__.iteritems()]
12356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12357 
 
12358 
  def __eq__(self, other):
12359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12360 
 
12361 
  def __ne__(self, other):
12362 
    return not (self == other)
12363 
 
3064 chandransh 12364 
class addBillingDetails_args:
1135 chandransh 12365 
  """
12366 
  Attributes:
3064 chandransh 12367 
   - orderId
12368 
   - invoice_number
4658 mandeep.dh 12369 
   - serialNumber
4283 anupam.sin 12370 
   - itemNumber
3064 chandransh 12371 
   - billed_by
4264 rajveer 12372 
   - jacketNumber
4283 anupam.sin 12373 
   - billingType
5110 mandeep.dh 12374 
   - fulfilmentWarehouseId
4763 rajveer 12375 
   - authorize
1135 chandransh 12376 
  """
12377 
 
12378 
  thrift_spec = (
12379 
    None, # 0
3064 chandransh 12380 
    (1, TType.I64, 'orderId', None, None, ), # 1
12381 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 12382 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
12383 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 12384 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
12385 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
12386 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 12387 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 12388 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 12389 
  )
12390 
 
5110 mandeep.dh 12391 
  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 12392 
    self.orderId = orderId
12393 
    self.invoice_number = invoice_number
4658 mandeep.dh 12394 
    self.serialNumber = serialNumber
4283 anupam.sin 12395 
    self.itemNumber = itemNumber
3064 chandransh 12396 
    self.billed_by = billed_by
4264 rajveer 12397 
    self.jacketNumber = jacketNumber
4283 anupam.sin 12398 
    self.billingType = billingType
5110 mandeep.dh 12399 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 12400 
    self.authorize = authorize
1135 chandransh 12401 
 
12402 
  def read(self, iprot):
12403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12405 
      return
12406 
    iprot.readStructBegin()
12407 
    while True:
12408 
      (fname, ftype, fid) = iprot.readFieldBegin()
12409 
      if ftype == TType.STOP:
12410 
        break
12411 
      if fid == 1:
12412 
        if ftype == TType.I64:
3064 chandransh 12413 
          self.orderId = iprot.readI64();
1135 chandransh 12414 
        else:
12415 
          iprot.skip(ftype)
12416 
      elif fid == 2:
3064 chandransh 12417 
        if ftype == TType.STRING:
12418 
          self.invoice_number = iprot.readString();
1135 chandransh 12419 
        else:
12420 
          iprot.skip(ftype)
3064 chandransh 12421 
      elif fid == 3:
5411 rajveer 12422 
        if ftype == TType.LIST:
12423 
          self.serialNumber = []
12424 
          (_etype227, _size224) = iprot.readListBegin()
12425 
          for _i228 in xrange(_size224):
12426 
            _elem229 = iprot.readString();
12427 
            self.serialNumber.append(_elem229)
12428 
          iprot.readListEnd()
3064 chandransh 12429 
        else:
12430 
          iprot.skip(ftype)
12431 
      elif fid == 4:
5411 rajveer 12432 
        if ftype == TType.LIST:
12433 
          self.itemNumber = []
12434 
          (_etype233, _size230) = iprot.readListBegin()
12435 
          for _i234 in xrange(_size230):
12436 
            _elem235 = iprot.readString();
12437 
            self.itemNumber.append(_elem235)
12438 
          iprot.readListEnd()
3064 chandransh 12439 
        else:
12440 
          iprot.skip(ftype)
12441 
      elif fid == 5:
12442 
        if ftype == TType.STRING:
4283 anupam.sin 12443 
          self.billed_by = iprot.readString();
3064 chandransh 12444 
        else:
12445 
          iprot.skip(ftype)
12446 
      elif fid == 6:
12447 
        if ftype == TType.I64:
4283 anupam.sin 12448 
          self.jacketNumber = iprot.readI64();
12449 
        else:
12450 
          iprot.skip(ftype)
12451 
      elif fid == 7:
12452 
        if ftype == TType.I64:
3064 chandransh 12453 
          self.billingType = iprot.readI64();
12454 
        else:
12455 
          iprot.skip(ftype)
4283 anupam.sin 12456 
      elif fid == 8:
12457 
        if ftype == TType.I64:
5110 mandeep.dh 12458 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 12459 
        else:
12460 
          iprot.skip(ftype)
4763 rajveer 12461 
      elif fid == 9:
12462 
        if ftype == TType.BOOL:
12463 
          self.authorize = iprot.readBool();
12464 
        else:
12465 
          iprot.skip(ftype)
1246 chandransh 12466 
      else:
12467 
        iprot.skip(ftype)
12468 
      iprot.readFieldEnd()
12469 
    iprot.readStructEnd()
12470 
 
12471 
  def write(self, oprot):
12472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12474 
      return
4283 anupam.sin 12475 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 12476 
    if self.orderId is not None:
3064 chandransh 12477 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12478 
      oprot.writeI64(self.orderId)
1246 chandransh 12479 
      oprot.writeFieldEnd()
4283 anupam.sin 12480 
    if self.invoice_number is not None:
12481 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
12482 
      oprot.writeString(self.invoice_number)
1246 chandransh 12483 
      oprot.writeFieldEnd()
4658 mandeep.dh 12484 
    if self.serialNumber is not None:
5411 rajveer 12485 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
12486 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
12487 
      for iter236 in self.serialNumber:
12488 
        oprot.writeString(iter236)
12489 
      oprot.writeListEnd()
3064 chandransh 12490 
      oprot.writeFieldEnd()
3431 rajveer 12491 
    if self.itemNumber is not None:
5411 rajveer 12492 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
12493 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
12494 
      for iter237 in self.itemNumber:
12495 
        oprot.writeString(iter237)
12496 
      oprot.writeListEnd()
3064 chandransh 12497 
      oprot.writeFieldEnd()
4283 anupam.sin 12498 
    if self.billed_by is not None:
12499 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
12500 
      oprot.writeString(self.billed_by)
3064 chandransh 12501 
      oprot.writeFieldEnd()
4283 anupam.sin 12502 
    if self.jacketNumber is not None:
12503 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
12504 
      oprot.writeI64(self.jacketNumber)
12505 
      oprot.writeFieldEnd()
3431 rajveer 12506 
    if self.billingType is not None:
4283 anupam.sin 12507 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 12508 
      oprot.writeI64(self.billingType)
12509 
      oprot.writeFieldEnd()
5110 mandeep.dh 12510 
    if self.fulfilmentWarehouseId is not None:
12511 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
12512 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 12513 
      oprot.writeFieldEnd()
4763 rajveer 12514 
    if self.authorize is not None:
12515 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
12516 
      oprot.writeBool(self.authorize)
12517 
      oprot.writeFieldEnd()
1246 chandransh 12518 
    oprot.writeFieldStop()
12519 
    oprot.writeStructEnd()
12520 
 
3431 rajveer 12521 
  def validate(self):
12522 
    return
12523 
 
12524 
 
1246 chandransh 12525 
  def __repr__(self):
12526 
    L = ['%s=%r' % (key, value)
12527 
      for key, value in self.__dict__.iteritems()]
12528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12529 
 
12530 
  def __eq__(self, other):
12531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12532 
 
12533 
  def __ne__(self, other):
12534 
    return not (self == other)
12535 
 
4283 anupam.sin 12536 
class addBillingDetails_result:
1246 chandransh 12537 
  """
12538 
  Attributes:
3064 chandransh 12539 
   - success
1246 chandransh 12540 
   - ex
12541 
  """
12542 
 
12543 
  thrift_spec = (
3064 chandransh 12544 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 12545 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12546 
  )
12547 
 
3064 chandransh 12548 
  def __init__(self, success=None, ex=None,):
12549 
    self.success = success
1246 chandransh 12550 
    self.ex = ex
12551 
 
12552 
  def read(self, iprot):
12553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12555 
      return
12556 
    iprot.readStructBegin()
12557 
    while True:
12558 
      (fname, ftype, fid) = iprot.readFieldBegin()
12559 
      if ftype == TType.STOP:
12560 
        break
3064 chandransh 12561 
      if fid == 0:
12562 
        if ftype == TType.BOOL:
12563 
          self.success = iprot.readBool();
12564 
        else:
12565 
          iprot.skip(ftype)
12566 
      elif fid == 1:
1246 chandransh 12567 
        if ftype == TType.STRUCT:
12568 
          self.ex = TransactionServiceException()
12569 
          self.ex.read(iprot)
12570 
        else:
12571 
          iprot.skip(ftype)
12572 
      else:
12573 
        iprot.skip(ftype)
12574 
      iprot.readFieldEnd()
12575 
    iprot.readStructEnd()
12576 
 
12577 
  def write(self, oprot):
12578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12580 
      return
4283 anupam.sin 12581 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 12582 
    if self.success is not None:
3064 chandransh 12583 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12584 
      oprot.writeBool(self.success)
12585 
      oprot.writeFieldEnd()
3431 rajveer 12586 
    if self.ex is not None:
1246 chandransh 12587 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12588 
      self.ex.write(oprot)
12589 
      oprot.writeFieldEnd()
12590 
    oprot.writeFieldStop()
12591 
    oprot.writeStructEnd()
12592 
 
3431 rajveer 12593 
  def validate(self):
12594 
    return
12595 
 
12596 
 
1246 chandransh 12597 
  def __repr__(self):
12598 
    L = ['%s=%r' % (key, value)
12599 
      for key, value in self.__dict__.iteritems()]
12600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12601 
 
12602 
  def __eq__(self, other):
12603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12604 
 
12605 
  def __ne__(self, other):
12606 
    return not (self == other)
12607 
 
4579 rajveer 12608 
class addInvoiceNumber_args:
12609 
  """
12610 
  Attributes:
12611 
   - orderId
12612 
   - invoiceNumber
4763 rajveer 12613 
   - color
4579 rajveer 12614 
  """
12615 
 
12616 
  thrift_spec = (
12617 
    None, # 0
12618 
    (1, TType.I64, 'orderId', None, None, ), # 1
12619 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 12620 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 12621 
  )
12622 
 
4763 rajveer 12623 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 12624 
    self.orderId = orderId
12625 
    self.invoiceNumber = invoiceNumber
4763 rajveer 12626 
    self.color = color
4579 rajveer 12627 
 
12628 
  def read(self, iprot):
12629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12631 
      return
12632 
    iprot.readStructBegin()
12633 
    while True:
12634 
      (fname, ftype, fid) = iprot.readFieldBegin()
12635 
      if ftype == TType.STOP:
12636 
        break
12637 
      if fid == 1:
12638 
        if ftype == TType.I64:
12639 
          self.orderId = iprot.readI64();
12640 
        else:
12641 
          iprot.skip(ftype)
12642 
      elif fid == 2:
12643 
        if ftype == TType.STRING:
12644 
          self.invoiceNumber = iprot.readString();
12645 
        else:
12646 
          iprot.skip(ftype)
4763 rajveer 12647 
      elif fid == 3:
12648 
        if ftype == TType.STRING:
12649 
          self.color = iprot.readString();
12650 
        else:
12651 
          iprot.skip(ftype)
4579 rajveer 12652 
      else:
12653 
        iprot.skip(ftype)
12654 
      iprot.readFieldEnd()
12655 
    iprot.readStructEnd()
12656 
 
12657 
  def write(self, oprot):
12658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12660 
      return
12661 
    oprot.writeStructBegin('addInvoiceNumber_args')
12662 
    if self.orderId is not None:
12663 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12664 
      oprot.writeI64(self.orderId)
12665 
      oprot.writeFieldEnd()
12666 
    if self.invoiceNumber is not None:
12667 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
12668 
      oprot.writeString(self.invoiceNumber)
12669 
      oprot.writeFieldEnd()
4763 rajveer 12670 
    if self.color is not None:
12671 
      oprot.writeFieldBegin('color', TType.STRING, 3)
12672 
      oprot.writeString(self.color)
12673 
      oprot.writeFieldEnd()
4579 rajveer 12674 
    oprot.writeFieldStop()
12675 
    oprot.writeStructEnd()
12676 
 
12677 
  def validate(self):
12678 
    return
12679 
 
12680 
 
12681 
  def __repr__(self):
12682 
    L = ['%s=%r' % (key, value)
12683 
      for key, value in self.__dict__.iteritems()]
12684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12685 
 
12686 
  def __eq__(self, other):
12687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12688 
 
12689 
  def __ne__(self, other):
12690 
    return not (self == other)
12691 
 
12692 
class addInvoiceNumber_result:
12693 
  """
12694 
  Attributes:
12695 
   - ex
12696 
  """
12697 
 
12698 
  thrift_spec = (
12699 
    None, # 0
12700 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12701 
  )
12702 
 
12703 
  def __init__(self, ex=None,):
12704 
    self.ex = ex
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 == 1:
12716 
        if ftype == TType.STRUCT:
12717 
          self.ex = TransactionServiceException()
12718 
          self.ex.read(iprot)
12719 
        else:
12720 
          iprot.skip(ftype)
12721 
      else:
12722 
        iprot.skip(ftype)
12723 
      iprot.readFieldEnd()
12724 
    iprot.readStructEnd()
12725 
 
12726 
  def write(self, oprot):
12727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12729 
      return
12730 
    oprot.writeStructBegin('addInvoiceNumber_result')
12731 
    if self.ex is not None:
12732 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12733 
      self.ex.write(oprot)
12734 
      oprot.writeFieldEnd()
12735 
    oprot.writeFieldStop()
12736 
    oprot.writeStructEnd()
12737 
 
12738 
  def validate(self):
12739 
    return
12740 
 
12741 
 
12742 
  def __repr__(self):
12743 
    L = ['%s=%r' % (key, value)
12744 
      for key, value in self.__dict__.iteritems()]
12745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12746 
 
12747 
  def __eq__(self, other):
12748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12749 
 
12750 
  def __ne__(self, other):
12751 
    return not (self == other)
12752 
 
4910 phani.kuma 12753 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 12754 
  """
12755 
  Attributes:
3064 chandransh 12756 
   - warehouseId
1408 ankur.sing 12757 
   - providerId
3064 chandransh 12758 
   - cod
4910 phani.kuma 12759 
   - orderIds
1408 ankur.sing 12760 
  """
12761 
 
12762 
  thrift_spec = (
12763 
    None, # 0
3064 chandransh 12764 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12765 
    (2, TType.I64, 'providerId', None, None, ), # 2
12766 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 12767 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 12768 
  )
12769 
 
4910 phani.kuma 12770 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 12771 
    self.warehouseId = warehouseId
1408 ankur.sing 12772 
    self.providerId = providerId
3064 chandransh 12773 
    self.cod = cod
4910 phani.kuma 12774 
    self.orderIds = orderIds
1408 ankur.sing 12775 
 
12776 
  def read(self, iprot):
12777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12779 
      return
12780 
    iprot.readStructBegin()
12781 
    while True:
12782 
      (fname, ftype, fid) = iprot.readFieldBegin()
12783 
      if ftype == TType.STOP:
12784 
        break
12785 
      if fid == 1:
12786 
        if ftype == TType.I64:
3064 chandransh 12787 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 12788 
        else:
12789 
          iprot.skip(ftype)
12790 
      elif fid == 2:
12791 
        if ftype == TType.I64:
3064 chandransh 12792 
          self.providerId = iprot.readI64();
1408 ankur.sing 12793 
        else:
12794 
          iprot.skip(ftype)
3064 chandransh 12795 
      elif fid == 3:
12796 
        if ftype == TType.BOOL:
12797 
          self.cod = iprot.readBool();
12798 
        else:
12799 
          iprot.skip(ftype)
4910 phani.kuma 12800 
      elif fid == 4:
12801 
        if ftype == TType.LIST:
12802 
          self.orderIds = []
5411 rajveer 12803 
          (_etype241, _size238) = iprot.readListBegin()
12804 
          for _i242 in xrange(_size238):
12805 
            _elem243 = iprot.readI64();
12806 
            self.orderIds.append(_elem243)
4910 phani.kuma 12807 
          iprot.readListEnd()
12808 
        else:
12809 
          iprot.skip(ftype)
1408 ankur.sing 12810 
      else:
12811 
        iprot.skip(ftype)
12812 
      iprot.readFieldEnd()
12813 
    iprot.readStructEnd()
12814 
 
12815 
  def write(self, oprot):
12816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12818 
      return
4910 phani.kuma 12819 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 12820 
    if self.warehouseId is not None:
3064 chandransh 12821 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12822 
      oprot.writeI64(self.warehouseId)
12823 
      oprot.writeFieldEnd()
3431 rajveer 12824 
    if self.providerId is not None:
3064 chandransh 12825 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 12826 
      oprot.writeI64(self.providerId)
12827 
      oprot.writeFieldEnd()
3431 rajveer 12828 
    if self.cod is not None:
3064 chandransh 12829 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
12830 
      oprot.writeBool(self.cod)
1408 ankur.sing 12831 
      oprot.writeFieldEnd()
4910 phani.kuma 12832 
    if self.orderIds is not None:
12833 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
12834 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5411 rajveer 12835 
      for iter244 in self.orderIds:
12836 
        oprot.writeI64(iter244)
4910 phani.kuma 12837 
      oprot.writeListEnd()
12838 
      oprot.writeFieldEnd()
1408 ankur.sing 12839 
    oprot.writeFieldStop()
12840 
    oprot.writeStructEnd()
12841 
 
3431 rajveer 12842 
  def validate(self):
12843 
    return
12844 
 
12845 
 
1408 ankur.sing 12846 
  def __repr__(self):
12847 
    L = ['%s=%r' % (key, value)
12848 
      for key, value in self.__dict__.iteritems()]
12849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12850 
 
12851 
  def __eq__(self, other):
12852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12853 
 
12854 
  def __ne__(self, other):
12855 
    return not (self == other)
12856 
 
4910 phani.kuma 12857 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 12858 
  """
12859 
  Attributes:
12860 
   - success
3064 chandransh 12861 
   - ex
1408 ankur.sing 12862 
  """
12863 
 
12864 
  thrift_spec = (
3064 chandransh 12865 
    (0, TType.BOOL, 'success', None, None, ), # 0
12866 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 12867 
  )
12868 
 
3064 chandransh 12869 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 12870 
    self.success = success
3064 chandransh 12871 
    self.ex = ex
1408 ankur.sing 12872 
 
12873 
  def read(self, iprot):
12874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12876 
      return
12877 
    iprot.readStructBegin()
12878 
    while True:
12879 
      (fname, ftype, fid) = iprot.readFieldBegin()
12880 
      if ftype == TType.STOP:
12881 
        break
12882 
      if fid == 0:
3064 chandransh 12883 
        if ftype == TType.BOOL:
12884 
          self.success = iprot.readBool();
1408 ankur.sing 12885 
        else:
12886 
          iprot.skip(ftype)
3064 chandransh 12887 
      elif fid == 1:
12888 
        if ftype == TType.STRUCT:
12889 
          self.ex = TransactionServiceException()
12890 
          self.ex.read(iprot)
12891 
        else:
12892 
          iprot.skip(ftype)
1408 ankur.sing 12893 
      else:
12894 
        iprot.skip(ftype)
12895 
      iprot.readFieldEnd()
12896 
    iprot.readStructEnd()
12897 
 
12898 
  def write(self, oprot):
12899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12901 
      return
4910 phani.kuma 12902 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 12903 
    if self.success is not None:
3064 chandransh 12904 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12905 
      oprot.writeBool(self.success)
1408 ankur.sing 12906 
      oprot.writeFieldEnd()
3431 rajveer 12907 
    if self.ex is not None:
3064 chandransh 12908 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12909 
      self.ex.write(oprot)
12910 
      oprot.writeFieldEnd()
1408 ankur.sing 12911 
    oprot.writeFieldStop()
12912 
    oprot.writeStructEnd()
12913 
 
3431 rajveer 12914 
  def validate(self):
12915 
    return
12916 
 
12917 
 
1408 ankur.sing 12918 
  def __repr__(self):
12919 
    L = ['%s=%r' % (key, value)
12920 
      for key, value in self.__dict__.iteritems()]
12921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12922 
 
12923 
  def __eq__(self, other):
12924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12925 
 
12926 
  def __ne__(self, other):
12927 
    return not (self == other)
12928 
 
5676 rajveer 12929 
class markOrdersAsReturnedFromStore_args:
12930 
  """
12931 
  Attributes:
12932 
   - providerId
12933 
   - orderIds
5713 rajveer 12934 
   - awbs
5676 rajveer 12935 
  """
12936 
 
12937 
  thrift_spec = (
12938 
    None, # 0
12939 
    (1, TType.I64, 'providerId', None, None, ), # 1
12940 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 12941 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 12942 
  )
12943 
 
5713 rajveer 12944 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 12945 
    self.providerId = providerId
12946 
    self.orderIds = orderIds
5713 rajveer 12947 
    self.awbs = awbs
5676 rajveer 12948 
 
12949 
  def read(self, iprot):
12950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12952 
      return
12953 
    iprot.readStructBegin()
12954 
    while True:
12955 
      (fname, ftype, fid) = iprot.readFieldBegin()
12956 
      if ftype == TType.STOP:
12957 
        break
12958 
      if fid == 1:
12959 
        if ftype == TType.I64:
12960 
          self.providerId = iprot.readI64();
12961 
        else:
12962 
          iprot.skip(ftype)
12963 
      elif fid == 2:
12964 
        if ftype == TType.LIST:
12965 
          self.orderIds = []
12966 
          (_etype248, _size245) = iprot.readListBegin()
12967 
          for _i249 in xrange(_size245):
12968 
            _elem250 = iprot.readI64();
12969 
            self.orderIds.append(_elem250)
12970 
          iprot.readListEnd()
12971 
        else:
12972 
          iprot.skip(ftype)
5713 rajveer 12973 
      elif fid == 3:
12974 
        if ftype == TType.LIST:
12975 
          self.awbs = []
12976 
          (_etype254, _size251) = iprot.readListBegin()
12977 
          for _i255 in xrange(_size251):
12978 
            _elem256 = iprot.readString();
12979 
            self.awbs.append(_elem256)
12980 
          iprot.readListEnd()
12981 
        else:
12982 
          iprot.skip(ftype)
5676 rajveer 12983 
      else:
12984 
        iprot.skip(ftype)
12985 
      iprot.readFieldEnd()
12986 
    iprot.readStructEnd()
12987 
 
12988 
  def write(self, oprot):
12989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12991 
      return
12992 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
12993 
    if self.providerId is not None:
12994 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12995 
      oprot.writeI64(self.providerId)
12996 
      oprot.writeFieldEnd()
12997 
    if self.orderIds is not None:
12998 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
12999 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5713 rajveer 13000 
      for iter257 in self.orderIds:
13001 
        oprot.writeI64(iter257)
5676 rajveer 13002 
      oprot.writeListEnd()
13003 
      oprot.writeFieldEnd()
5713 rajveer 13004 
    if self.awbs is not None:
13005 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
13006 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
13007 
      for iter258 in self.awbs:
13008 
        oprot.writeString(iter258)
13009 
      oprot.writeListEnd()
13010 
      oprot.writeFieldEnd()
5676 rajveer 13011 
    oprot.writeFieldStop()
13012 
    oprot.writeStructEnd()
13013 
 
13014 
  def validate(self):
13015 
    return
13016 
 
13017 
 
13018 
  def __repr__(self):
13019 
    L = ['%s=%r' % (key, value)
13020 
      for key, value in self.__dict__.iteritems()]
13021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13022 
 
13023 
  def __eq__(self, other):
13024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13025 
 
13026 
  def __ne__(self, other):
13027 
    return not (self == other)
13028 
 
13029 
class markOrdersAsReturnedFromStore_result:
13030 
  """
13031 
  Attributes:
13032 
   - success
13033 
   - ex
13034 
  """
13035 
 
13036 
  thrift_spec = (
13037 
    (0, TType.BOOL, 'success', None, None, ), # 0
13038 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13039 
  )
13040 
 
13041 
  def __init__(self, success=None, ex=None,):
13042 
    self.success = success
13043 
    self.ex = ex
13044 
 
13045 
  def read(self, iprot):
13046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13048 
      return
13049 
    iprot.readStructBegin()
13050 
    while True:
13051 
      (fname, ftype, fid) = iprot.readFieldBegin()
13052 
      if ftype == TType.STOP:
13053 
        break
13054 
      if fid == 0:
13055 
        if ftype == TType.BOOL:
13056 
          self.success = iprot.readBool();
13057 
        else:
13058 
          iprot.skip(ftype)
13059 
      elif fid == 1:
13060 
        if ftype == TType.STRUCT:
13061 
          self.ex = TransactionServiceException()
13062 
          self.ex.read(iprot)
13063 
        else:
13064 
          iprot.skip(ftype)
13065 
      else:
13066 
        iprot.skip(ftype)
13067 
      iprot.readFieldEnd()
13068 
    iprot.readStructEnd()
13069 
 
13070 
  def write(self, oprot):
13071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13073 
      return
13074 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
13075 
    if self.success is not None:
13076 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13077 
      oprot.writeBool(self.success)
13078 
      oprot.writeFieldEnd()
13079 
    if self.ex is not None:
13080 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13081 
      self.ex.write(oprot)
13082 
      oprot.writeFieldEnd()
13083 
    oprot.writeFieldStop()
13084 
    oprot.writeStructEnd()
13085 
 
13086 
  def validate(self):
13087 
    return
13088 
 
13089 
 
13090 
  def __repr__(self):
13091 
    L = ['%s=%r' % (key, value)
13092 
      for key, value in self.__dict__.iteritems()]
13093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13094 
 
13095 
  def __eq__(self, other):
13096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13097 
 
13098 
  def __ne__(self, other):
13099 
    return not (self == other)
13100 
 
4910 phani.kuma 13101 
class markOrdersAsPickedUp_args:
4410 rajveer 13102 
  """
13103 
  Attributes:
13104 
   - providerId
4910 phani.kuma 13105 
   - pickupDetails
4410 rajveer 13106 
  """
13107 
 
13108 
  thrift_spec = (
13109 
    None, # 0
4910 phani.kuma 13110 
    (1, TType.I64, 'providerId', None, None, ), # 1
13111 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 13112 
  )
13113 
 
4910 phani.kuma 13114 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 13115 
    self.providerId = providerId
4910 phani.kuma 13116 
    self.pickupDetails = pickupDetails
4410 rajveer 13117 
 
13118 
  def read(self, iprot):
13119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13121 
      return
13122 
    iprot.readStructBegin()
13123 
    while True:
13124 
      (fname, ftype, fid) = iprot.readFieldBegin()
13125 
      if ftype == TType.STOP:
13126 
        break
13127 
      if fid == 1:
13128 
        if ftype == TType.I64:
4910 phani.kuma 13129 
          self.providerId = iprot.readI64();
4410 rajveer 13130 
        else:
13131 
          iprot.skip(ftype)
13132 
      elif fid == 2:
4910 phani.kuma 13133 
        if ftype == TType.MAP:
13134 
          self.pickupDetails = {}
5713 rajveer 13135 
          (_ktype260, _vtype261, _size259 ) = iprot.readMapBegin()
13136 
          for _i263 in xrange(_size259):
13137 
            _key264 = iprot.readString();
13138 
            _val265 = iprot.readString();
13139 
            self.pickupDetails[_key264] = _val265
4910 phani.kuma 13140 
          iprot.readMapEnd()
4410 rajveer 13141 
        else:
13142 
          iprot.skip(ftype)
13143 
      else:
13144 
        iprot.skip(ftype)
13145 
      iprot.readFieldEnd()
13146 
    iprot.readStructEnd()
13147 
 
13148 
  def write(self, oprot):
13149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13151 
      return
4910 phani.kuma 13152 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 13153 
    if self.providerId is not None:
4910 phani.kuma 13154 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 13155 
      oprot.writeI64(self.providerId)
13156 
      oprot.writeFieldEnd()
4910 phani.kuma 13157 
    if self.pickupDetails is not None:
13158 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13159 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5713 rajveer 13160 
      for kiter266,viter267 in self.pickupDetails.items():
13161 
        oprot.writeString(kiter266)
13162 
        oprot.writeString(viter267)
4910 phani.kuma 13163 
      oprot.writeMapEnd()
4410 rajveer 13164 
      oprot.writeFieldEnd()
13165 
    oprot.writeFieldStop()
13166 
    oprot.writeStructEnd()
13167 
 
13168 
  def validate(self):
13169 
    return
13170 
 
13171 
 
13172 
  def __repr__(self):
13173 
    L = ['%s=%r' % (key, value)
13174 
      for key, value in self.__dict__.iteritems()]
13175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13176 
 
13177 
  def __eq__(self, other):
13178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13179 
 
13180 
  def __ne__(self, other):
13181 
    return not (self == other)
13182 
 
4910 phani.kuma 13183 
class markOrdersAsPickedUp_result:
4410 rajveer 13184 
  """
13185 
  Attributes:
13186 
   - ex
13187 
  """
13188 
 
13189 
  thrift_spec = (
4910 phani.kuma 13190 
    None, # 0
4410 rajveer 13191 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13192 
  )
13193 
 
4910 phani.kuma 13194 
  def __init__(self, ex=None,):
4410 rajveer 13195 
    self.ex = ex
13196 
 
13197 
  def read(self, iprot):
13198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13200 
      return
13201 
    iprot.readStructBegin()
13202 
    while True:
13203 
      (fname, ftype, fid) = iprot.readFieldBegin()
13204 
      if ftype == TType.STOP:
13205 
        break
4910 phani.kuma 13206 
      if fid == 1:
4410 rajveer 13207 
        if ftype == TType.STRUCT:
13208 
          self.ex = TransactionServiceException()
13209 
          self.ex.read(iprot)
13210 
        else:
13211 
          iprot.skip(ftype)
13212 
      else:
13213 
        iprot.skip(ftype)
13214 
      iprot.readFieldEnd()
13215 
    iprot.readStructEnd()
13216 
 
13217 
  def write(self, oprot):
13218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13220 
      return
4910 phani.kuma 13221 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 13222 
    if self.ex is not None:
13223 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13224 
      self.ex.write(oprot)
13225 
      oprot.writeFieldEnd()
13226 
    oprot.writeFieldStop()
13227 
    oprot.writeStructEnd()
13228 
 
13229 
  def validate(self):
13230 
    return
13231 
 
13232 
 
13233 
  def __repr__(self):
13234 
    L = ['%s=%r' % (key, value)
13235 
      for key, value in self.__dict__.iteritems()]
13236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13237 
 
13238 
  def __eq__(self, other):
13239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13240 
 
13241 
  def __ne__(self, other):
13242 
    return not (self == other)
13243 
 
4910 phani.kuma 13244 
class getOrdersNotPickedUp_args:
304 ashish 13245 
  """
13246 
  Attributes:
3064 chandransh 13247 
   - providerId
304 ashish 13248 
  """
94 ashish 13249 
 
304 ashish 13250 
  thrift_spec = (
13251 
    None, # 0
3064 chandransh 13252 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 13253 
  )
13254 
 
4910 phani.kuma 13255 
  def __init__(self, providerId=None,):
3064 chandransh 13256 
    self.providerId = providerId
304 ashish 13257 
 
13258 
  def read(self, iprot):
13259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13261 
      return
13262 
    iprot.readStructBegin()
13263 
    while True:
13264 
      (fname, ftype, fid) = iprot.readFieldBegin()
13265 
      if ftype == TType.STOP:
13266 
        break
13267 
      if fid == 1:
13268 
        if ftype == TType.I64:
3064 chandransh 13269 
          self.providerId = iprot.readI64();
304 ashish 13270 
        else:
13271 
          iprot.skip(ftype)
13272 
      else:
13273 
        iprot.skip(ftype)
13274 
      iprot.readFieldEnd()
13275 
    iprot.readStructEnd()
13276 
 
13277 
  def write(self, oprot):
13278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13280 
      return
4910 phani.kuma 13281 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 13282 
    if self.providerId is not None:
3064 chandransh 13283 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13284 
      oprot.writeI64(self.providerId)
304 ashish 13285 
      oprot.writeFieldEnd()
13286 
    oprot.writeFieldStop()
13287 
    oprot.writeStructEnd()
13288 
 
3431 rajveer 13289 
  def validate(self):
13290 
    return
13291 
 
13292 
 
304 ashish 13293 
  def __repr__(self):
13294 
    L = ['%s=%r' % (key, value)
13295 
      for key, value in self.__dict__.iteritems()]
13296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13297 
 
13298 
  def __eq__(self, other):
13299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13300 
 
13301 
  def __ne__(self, other):
13302 
    return not (self == other)
13303 
 
4910 phani.kuma 13304 
class getOrdersNotPickedUp_result:
304 ashish 13305 
  """
13306 
  Attributes:
13307 
   - success
13308 
  """
13309 
 
13310 
  thrift_spec = (
3064 chandransh 13311 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 13312 
  )
13313 
 
4910 phani.kuma 13314 
  def __init__(self, success=None,):
304 ashish 13315 
    self.success = success
13316 
 
13317 
  def read(self, iprot):
13318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13320 
      return
13321 
    iprot.readStructBegin()
13322 
    while True:
13323 
      (fname, ftype, fid) = iprot.readFieldBegin()
13324 
      if ftype == TType.STOP:
13325 
        break
13326 
      if fid == 0:
13327 
        if ftype == TType.LIST:
13328 
          self.success = []
5713 rajveer 13329 
          (_etype271, _size268) = iprot.readListBegin()
13330 
          for _i272 in xrange(_size268):
13331 
            _elem273 = Order()
13332 
            _elem273.read(iprot)
13333 
            self.success.append(_elem273)
304 ashish 13334 
          iprot.readListEnd()
13335 
        else:
13336 
          iprot.skip(ftype)
13337 
      else:
13338 
        iprot.skip(ftype)
13339 
      iprot.readFieldEnd()
13340 
    iprot.readStructEnd()
13341 
 
13342 
  def write(self, oprot):
13343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13345 
      return
4910 phani.kuma 13346 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 13347 
    if self.success is not None:
304 ashish 13348 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13349 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 13350 
      for iter274 in self.success:
13351 
        iter274.write(oprot)
304 ashish 13352 
      oprot.writeListEnd()
13353 
      oprot.writeFieldEnd()
13354 
    oprot.writeFieldStop()
13355 
    oprot.writeStructEnd()
13356 
 
3431 rajveer 13357 
  def validate(self):
13358 
    return
13359 
 
13360 
 
304 ashish 13361 
  def __repr__(self):
13362 
    L = ['%s=%r' % (key, value)
13363 
      for key, value in self.__dict__.iteritems()]
13364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13365 
 
13366 
  def __eq__(self, other):
13367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13368 
 
13369 
  def __ne__(self, other):
13370 
    return not (self == other)
13371 
 
3064 chandransh 13372 
class markOrdersAsDelivered_args:
304 ashish 13373 
  """
13374 
  Attributes:
3064 chandransh 13375 
   - providerId
13376 
   - deliveredOrders
304 ashish 13377 
  """
13378 
 
13379 
  thrift_spec = (
13380 
    None, # 0
3064 chandransh 13381 
    (1, TType.I64, 'providerId', None, None, ), # 1
13382 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 13383 
  )
13384 
 
3064 chandransh 13385 
  def __init__(self, providerId=None, deliveredOrders=None,):
13386 
    self.providerId = providerId
13387 
    self.deliveredOrders = deliveredOrders
304 ashish 13388 
 
13389 
  def read(self, iprot):
13390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13392 
      return
13393 
    iprot.readStructBegin()
13394 
    while True:
13395 
      (fname, ftype, fid) = iprot.readFieldBegin()
13396 
      if ftype == TType.STOP:
13397 
        break
13398 
      if fid == 1:
13399 
        if ftype == TType.I64:
3064 chandransh 13400 
          self.providerId = iprot.readI64();
304 ashish 13401 
        else:
13402 
          iprot.skip(ftype)
13403 
      elif fid == 2:
3064 chandransh 13404 
        if ftype == TType.MAP:
13405 
          self.deliveredOrders = {}
5713 rajveer 13406 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
13407 
          for _i279 in xrange(_size275):
13408 
            _key280 = iprot.readString();
13409 
            _val281 = iprot.readString();
13410 
            self.deliveredOrders[_key280] = _val281
3064 chandransh 13411 
          iprot.readMapEnd()
304 ashish 13412 
        else:
13413 
          iprot.skip(ftype)
13414 
      else:
13415 
        iprot.skip(ftype)
13416 
      iprot.readFieldEnd()
13417 
    iprot.readStructEnd()
13418 
 
13419 
  def write(self, oprot):
13420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13422 
      return
3064 chandransh 13423 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 13424 
    if self.providerId is not None:
3064 chandransh 13425 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13426 
      oprot.writeI64(self.providerId)
304 ashish 13427 
      oprot.writeFieldEnd()
3431 rajveer 13428 
    if self.deliveredOrders is not None:
3064 chandransh 13429 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
13430 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5713 rajveer 13431 
      for kiter282,viter283 in self.deliveredOrders.items():
13432 
        oprot.writeString(kiter282)
13433 
        oprot.writeString(viter283)
3064 chandransh 13434 
      oprot.writeMapEnd()
304 ashish 13435 
      oprot.writeFieldEnd()
13436 
    oprot.writeFieldStop()
13437 
    oprot.writeStructEnd()
13438 
 
3431 rajveer 13439 
  def validate(self):
13440 
    return
13441 
 
13442 
 
304 ashish 13443 
  def __repr__(self):
13444 
    L = ['%s=%r' % (key, value)
13445 
      for key, value in self.__dict__.iteritems()]
13446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13447 
 
13448 
  def __eq__(self, other):
13449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13450 
 
13451 
  def __ne__(self, other):
13452 
    return not (self == other)
13453 
 
3064 chandransh 13454 
class markOrdersAsDelivered_result:
13455 
  """
13456 
  Attributes:
13457 
   - ex
13458 
  """
304 ashish 13459 
 
13460 
  thrift_spec = (
3064 chandransh 13461 
    None, # 0
13462 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 13463 
  )
13464 
 
3064 chandransh 13465 
  def __init__(self, ex=None,):
13466 
    self.ex = ex
304 ashish 13467 
 
1596 ankur.sing 13468 
  def read(self, iprot):
13469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13471 
      return
13472 
    iprot.readStructBegin()
13473 
    while True:
13474 
      (fname, ftype, fid) = iprot.readFieldBegin()
13475 
      if ftype == TType.STOP:
13476 
        break
3064 chandransh 13477 
      if fid == 1:
13478 
        if ftype == TType.STRUCT:
13479 
          self.ex = TransactionServiceException()
13480 
          self.ex.read(iprot)
13481 
        else:
13482 
          iprot.skip(ftype)
1596 ankur.sing 13483 
      else:
13484 
        iprot.skip(ftype)
13485 
      iprot.readFieldEnd()
13486 
    iprot.readStructEnd()
13487 
 
13488 
  def write(self, oprot):
13489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13491 
      return
3064 chandransh 13492 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 13493 
    if self.ex is not None:
3064 chandransh 13494 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13495 
      self.ex.write(oprot)
13496 
      oprot.writeFieldEnd()
1596 ankur.sing 13497 
    oprot.writeFieldStop()
13498 
    oprot.writeStructEnd()
13499 
 
3431 rajveer 13500 
  def validate(self):
13501 
    return
13502 
 
13503 
 
1596 ankur.sing 13504 
  def __repr__(self):
13505 
    L = ['%s=%r' % (key, value)
13506 
      for key, value in self.__dict__.iteritems()]
13507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13508 
 
13509 
  def __eq__(self, other):
13510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13511 
 
13512 
  def __ne__(self, other):
13513 
    return not (self == other)
13514 
 
4910 phani.kuma 13515 
class markAsRTOrders_args:
1596 ankur.sing 13516 
  """
13517 
  Attributes:
3064 chandransh 13518 
   - providerId
13519 
   - returnedOrders
1596 ankur.sing 13520 
  """
13521 
 
13522 
  thrift_spec = (
3064 chandransh 13523 
    None, # 0
13524 
    (1, TType.I64, 'providerId', None, None, ), # 1
13525 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 13526 
  )
13527 
 
3064 chandransh 13528 
  def __init__(self, providerId=None, returnedOrders=None,):
13529 
    self.providerId = providerId
13530 
    self.returnedOrders = returnedOrders
1596 ankur.sing 13531 
 
13532 
  def read(self, iprot):
13533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13535 
      return
13536 
    iprot.readStructBegin()
13537 
    while True:
13538 
      (fname, ftype, fid) = iprot.readFieldBegin()
13539 
      if ftype == TType.STOP:
13540 
        break
3064 chandransh 13541 
      if fid == 1:
1596 ankur.sing 13542 
        if ftype == TType.I64:
3064 chandransh 13543 
          self.providerId = iprot.readI64();
1596 ankur.sing 13544 
        else:
13545 
          iprot.skip(ftype)
3064 chandransh 13546 
      elif fid == 2:
13547 
        if ftype == TType.MAP:
13548 
          self.returnedOrders = {}
5713 rajveer 13549 
          (_ktype285, _vtype286, _size284 ) = iprot.readMapBegin()
13550 
          for _i288 in xrange(_size284):
13551 
            _key289 = iprot.readString();
13552 
            _val290 = iprot.readString();
13553 
            self.returnedOrders[_key289] = _val290
3064 chandransh 13554 
          iprot.readMapEnd()
13555 
        else:
13556 
          iprot.skip(ftype)
1596 ankur.sing 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('markAsRTOrders_args')
3431 rajveer 13567 
    if self.providerId is not None:
3064 chandransh 13568 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13569 
      oprot.writeI64(self.providerId)
1596 ankur.sing 13570 
      oprot.writeFieldEnd()
3431 rajveer 13571 
    if self.returnedOrders is not None:
3064 chandransh 13572 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
13573 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5713 rajveer 13574 
      for kiter291,viter292 in self.returnedOrders.items():
13575 
        oprot.writeString(kiter291)
13576 
        oprot.writeString(viter292)
3064 chandransh 13577 
      oprot.writeMapEnd()
13578 
      oprot.writeFieldEnd()
1596 ankur.sing 13579 
    oprot.writeFieldStop()
13580 
    oprot.writeStructEnd()
13581 
 
3431 rajveer 13582 
  def validate(self):
13583 
    return
13584 
 
13585 
 
1596 ankur.sing 13586 
  def __repr__(self):
13587 
    L = ['%s=%r' % (key, value)
13588 
      for key, value in self.__dict__.iteritems()]
13589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13590 
 
13591 
  def __eq__(self, other):
13592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13593 
 
13594 
  def __ne__(self, other):
13595 
    return not (self == other)
13596 
 
4910 phani.kuma 13597 
class markAsRTOrders_result:
3064 chandransh 13598 
  """
13599 
  Attributes:
13600 
   - ex
13601 
  """
1596 ankur.sing 13602 
 
1627 ankur.sing 13603 
  thrift_spec = (
3064 chandransh 13604 
    None, # 0
13605 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13606 
  )
13607 
 
3064 chandransh 13608 
  def __init__(self, ex=None,):
13609 
    self.ex = ex
13610 
 
1627 ankur.sing 13611 
  def read(self, iprot):
13612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13614 
      return
13615 
    iprot.readStructBegin()
13616 
    while True:
13617 
      (fname, ftype, fid) = iprot.readFieldBegin()
13618 
      if ftype == TType.STOP:
13619 
        break
3064 chandransh 13620 
      if fid == 1:
13621 
        if ftype == TType.STRUCT:
13622 
          self.ex = TransactionServiceException()
13623 
          self.ex.read(iprot)
13624 
        else:
13625 
          iprot.skip(ftype)
1627 ankur.sing 13626 
      else:
13627 
        iprot.skip(ftype)
13628 
      iprot.readFieldEnd()
13629 
    iprot.readStructEnd()
13630 
 
13631 
  def write(self, oprot):
13632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13634 
      return
4910 phani.kuma 13635 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 13636 
    if self.ex is not None:
3064 chandransh 13637 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13638 
      self.ex.write(oprot)
13639 
      oprot.writeFieldEnd()
1627 ankur.sing 13640 
    oprot.writeFieldStop()
13641 
    oprot.writeStructEnd()
13642 
 
3431 rajveer 13643 
  def validate(self):
13644 
    return
13645 
 
13646 
 
1627 ankur.sing 13647 
  def __repr__(self):
13648 
    L = ['%s=%r' % (key, value)
13649 
      for key, value in self.__dict__.iteritems()]
13650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13651 
 
13652 
  def __eq__(self, other):
13653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13654 
 
13655 
  def __ne__(self, other):
13656 
    return not (self == other)
13657 
 
4910 phani.kuma 13658 
class getRTOrders_args:
13659 
  """
13660 
  Attributes:
13661 
   - providerId
13662 
  """
13663 
 
13664 
  thrift_spec = (
13665 
    None, # 0
13666 
    (1, TType.I64, 'providerId', None, None, ), # 1
13667 
  )
13668 
 
13669 
  def __init__(self, providerId=None,):
13670 
    self.providerId = providerId
13671 
 
13672 
  def read(self, iprot):
13673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13675 
      return
13676 
    iprot.readStructBegin()
13677 
    while True:
13678 
      (fname, ftype, fid) = iprot.readFieldBegin()
13679 
      if ftype == TType.STOP:
13680 
        break
13681 
      if fid == 1:
13682 
        if ftype == TType.I64:
13683 
          self.providerId = iprot.readI64();
13684 
        else:
13685 
          iprot.skip(ftype)
13686 
      else:
13687 
        iprot.skip(ftype)
13688 
      iprot.readFieldEnd()
13689 
    iprot.readStructEnd()
13690 
 
13691 
  def write(self, oprot):
13692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13694 
      return
13695 
    oprot.writeStructBegin('getRTOrders_args')
13696 
    if self.providerId is not None:
13697 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13698 
      oprot.writeI64(self.providerId)
13699 
      oprot.writeFieldEnd()
13700 
    oprot.writeFieldStop()
13701 
    oprot.writeStructEnd()
13702 
 
13703 
  def validate(self):
13704 
    return
13705 
 
13706 
 
13707 
  def __repr__(self):
13708 
    L = ['%s=%r' % (key, value)
13709 
      for key, value in self.__dict__.iteritems()]
13710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13711 
 
13712 
  def __eq__(self, other):
13713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13714 
 
13715 
  def __ne__(self, other):
13716 
    return not (self == other)
13717 
 
13718 
class getRTOrders_result:
13719 
  """
13720 
  Attributes:
13721 
   - success
13722 
  """
13723 
 
13724 
  thrift_spec = (
13725 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13726 
  )
13727 
 
13728 
  def __init__(self, success=None,):
13729 
    self.success = success
13730 
 
13731 
  def read(self, iprot):
13732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13734 
      return
13735 
    iprot.readStructBegin()
13736 
    while True:
13737 
      (fname, ftype, fid) = iprot.readFieldBegin()
13738 
      if ftype == TType.STOP:
13739 
        break
13740 
      if fid == 0:
13741 
        if ftype == TType.LIST:
13742 
          self.success = []
5713 rajveer 13743 
          (_etype296, _size293) = iprot.readListBegin()
13744 
          for _i297 in xrange(_size293):
13745 
            _elem298 = Order()
13746 
            _elem298.read(iprot)
13747 
            self.success.append(_elem298)
4910 phani.kuma 13748 
          iprot.readListEnd()
13749 
        else:
13750 
          iprot.skip(ftype)
13751 
      else:
13752 
        iprot.skip(ftype)
13753 
      iprot.readFieldEnd()
13754 
    iprot.readStructEnd()
13755 
 
13756 
  def write(self, oprot):
13757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13759 
      return
13760 
    oprot.writeStructBegin('getRTOrders_result')
13761 
    if self.success is not None:
13762 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13763 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 13764 
      for iter299 in self.success:
13765 
        iter299.write(oprot)
4910 phani.kuma 13766 
      oprot.writeListEnd()
13767 
      oprot.writeFieldEnd()
13768 
    oprot.writeFieldStop()
13769 
    oprot.writeStructEnd()
13770 
 
13771 
  def validate(self):
13772 
    return
13773 
 
13774 
 
13775 
  def __repr__(self):
13776 
    L = ['%s=%r' % (key, value)
13777 
      for key, value in self.__dict__.iteritems()]
13778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13779 
 
13780 
  def __eq__(self, other):
13781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13782 
 
13783 
  def __ne__(self, other):
13784 
    return not (self == other)
13785 
 
3064 chandransh 13786 
class updateNonDeliveryReason_args:
1627 ankur.sing 13787 
  """
13788 
  Attributes:
3064 chandransh 13789 
   - providerId
13790 
   - undeliveredOrders
1627 ankur.sing 13791 
  """
13792 
 
13793 
  thrift_spec = (
3064 chandransh 13794 
    None, # 0
13795 
    (1, TType.I64, 'providerId', None, None, ), # 1
13796 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 13797 
  )
13798 
 
3064 chandransh 13799 
  def __init__(self, providerId=None, undeliveredOrders=None,):
13800 
    self.providerId = providerId
13801 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 13802 
 
13803 
  def read(self, iprot):
13804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13806 
      return
13807 
    iprot.readStructBegin()
13808 
    while True:
13809 
      (fname, ftype, fid) = iprot.readFieldBegin()
13810 
      if ftype == TType.STOP:
13811 
        break
3064 chandransh 13812 
      if fid == 1:
1627 ankur.sing 13813 
        if ftype == TType.I64:
3064 chandransh 13814 
          self.providerId = iprot.readI64();
1627 ankur.sing 13815 
        else:
13816 
          iprot.skip(ftype)
3064 chandransh 13817 
      elif fid == 2:
13818 
        if ftype == TType.MAP:
13819 
          self.undeliveredOrders = {}
5713 rajveer 13820 
          (_ktype301, _vtype302, _size300 ) = iprot.readMapBegin()
13821 
          for _i304 in xrange(_size300):
13822 
            _key305 = iprot.readString();
13823 
            _val306 = iprot.readString();
13824 
            self.undeliveredOrders[_key305] = _val306
3064 chandransh 13825 
          iprot.readMapEnd()
13826 
        else:
13827 
          iprot.skip(ftype)
1627 ankur.sing 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
3064 chandransh 13837 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 13838 
    if self.providerId is not None:
3064 chandransh 13839 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13840 
      oprot.writeI64(self.providerId)
1627 ankur.sing 13841 
      oprot.writeFieldEnd()
3431 rajveer 13842 
    if self.undeliveredOrders is not None:
3064 chandransh 13843 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
13844 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5713 rajveer 13845 
      for kiter307,viter308 in self.undeliveredOrders.items():
13846 
        oprot.writeString(kiter307)
13847 
        oprot.writeString(viter308)
3064 chandransh 13848 
      oprot.writeMapEnd()
13849 
      oprot.writeFieldEnd()
1627 ankur.sing 13850 
    oprot.writeFieldStop()
13851 
    oprot.writeStructEnd()
13852 
 
3431 rajveer 13853 
  def validate(self):
13854 
    return
13855 
 
13856 
 
1627 ankur.sing 13857 
  def __repr__(self):
13858 
    L = ['%s=%r' % (key, value)
13859 
      for key, value in self.__dict__.iteritems()]
13860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13861 
 
13862 
  def __eq__(self, other):
13863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13864 
 
13865 
  def __ne__(self, other):
13866 
    return not (self == other)
13867 
 
3064 chandransh 13868 
class updateNonDeliveryReason_result:
1627 ankur.sing 13869 
  """
13870 
  Attributes:
3064 chandransh 13871 
   - ex
1627 ankur.sing 13872 
  """
13873 
 
13874 
  thrift_spec = (
4910 phani.kuma 13875 
    None, # 0
3064 chandransh 13876 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13877 
  )
13878 
 
4910 phani.kuma 13879 
  def __init__(self, ex=None,):
3064 chandransh 13880 
    self.ex = ex
1627 ankur.sing 13881 
 
13882 
  def read(self, iprot):
13883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13885 
      return
13886 
    iprot.readStructBegin()
13887 
    while True:
13888 
      (fname, ftype, fid) = iprot.readFieldBegin()
13889 
      if ftype == TType.STOP:
13890 
        break
4910 phani.kuma 13891 
      if fid == 1:
13892 
        if ftype == TType.STRUCT:
13893 
          self.ex = TransactionServiceException()
13894 
          self.ex.read(iprot)
13895 
        else:
13896 
          iprot.skip(ftype)
13897 
      else:
13898 
        iprot.skip(ftype)
13899 
      iprot.readFieldEnd()
13900 
    iprot.readStructEnd()
13901 
 
13902 
  def write(self, oprot):
13903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13905 
      return
13906 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
13907 
    if self.ex is not None:
13908 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13909 
      self.ex.write(oprot)
13910 
      oprot.writeFieldEnd()
13911 
    oprot.writeFieldStop()
13912 
    oprot.writeStructEnd()
13913 
 
13914 
  def validate(self):
13915 
    return
13916 
 
13917 
 
13918 
  def __repr__(self):
13919 
    L = ['%s=%r' % (key, value)
13920 
      for key, value in self.__dict__.iteritems()]
13921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13922 
 
13923 
  def __eq__(self, other):
13924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13925 
 
13926 
  def __ne__(self, other):
13927 
    return not (self == other)
13928 
 
13929 
class getNonDeliveredOrdersbyCourier_args:
13930 
  """
13931 
  Attributes:
13932 
   - providerId
13933 
  """
13934 
 
13935 
  thrift_spec = (
13936 
    None, # 0
13937 
    (1, TType.I64, 'providerId', None, None, ), # 1
13938 
  )
13939 
 
13940 
  def __init__(self, providerId=None,):
13941 
    self.providerId = providerId
13942 
 
13943 
  def read(self, iprot):
13944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13946 
      return
13947 
    iprot.readStructBegin()
13948 
    while True:
13949 
      (fname, ftype, fid) = iprot.readFieldBegin()
13950 
      if ftype == TType.STOP:
13951 
        break
13952 
      if fid == 1:
13953 
        if ftype == TType.I64:
13954 
          self.providerId = iprot.readI64();
13955 
        else:
13956 
          iprot.skip(ftype)
13957 
      else:
13958 
        iprot.skip(ftype)
13959 
      iprot.readFieldEnd()
13960 
    iprot.readStructEnd()
13961 
 
13962 
  def write(self, oprot):
13963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13965 
      return
13966 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
13967 
    if self.providerId is not None:
13968 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13969 
      oprot.writeI64(self.providerId)
13970 
      oprot.writeFieldEnd()
13971 
    oprot.writeFieldStop()
13972 
    oprot.writeStructEnd()
13973 
 
13974 
  def validate(self):
13975 
    return
13976 
 
13977 
 
13978 
  def __repr__(self):
13979 
    L = ['%s=%r' % (key, value)
13980 
      for key, value in self.__dict__.iteritems()]
13981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13982 
 
13983 
  def __eq__(self, other):
13984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13985 
 
13986 
  def __ne__(self, other):
13987 
    return not (self == other)
13988 
 
13989 
class getNonDeliveredOrdersbyCourier_result:
13990 
  """
13991 
  Attributes:
13992 
   - success
13993 
  """
13994 
 
13995 
  thrift_spec = (
13996 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13997 
  )
13998 
 
13999 
  def __init__(self, success=None,):
14000 
    self.success = success
14001 
 
14002 
  def read(self, iprot):
14003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14005 
      return
14006 
    iprot.readStructBegin()
14007 
    while True:
14008 
      (fname, ftype, fid) = iprot.readFieldBegin()
14009 
      if ftype == TType.STOP:
14010 
        break
4581 phani.kuma 14011 
      if fid == 0:
14012 
        if ftype == TType.LIST:
14013 
          self.success = []
5713 rajveer 14014 
          (_etype312, _size309) = iprot.readListBegin()
14015 
          for _i313 in xrange(_size309):
14016 
            _elem314 = Order()
14017 
            _elem314.read(iprot)
14018 
            self.success.append(_elem314)
4581 phani.kuma 14019 
          iprot.readListEnd()
14020 
        else:
14021 
          iprot.skip(ftype)
4910 phani.kuma 14022 
      else:
14023 
        iprot.skip(ftype)
14024 
      iprot.readFieldEnd()
14025 
    iprot.readStructEnd()
14026 
 
14027 
  def write(self, oprot):
14028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14030 
      return
14031 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
14032 
    if self.success is not None:
14033 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14034 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 14035 
      for iter315 in self.success:
14036 
        iter315.write(oprot)
4910 phani.kuma 14037 
      oprot.writeListEnd()
14038 
      oprot.writeFieldEnd()
14039 
    oprot.writeFieldStop()
14040 
    oprot.writeStructEnd()
14041 
 
14042 
  def validate(self):
14043 
    return
14044 
 
14045 
 
14046 
  def __repr__(self):
14047 
    L = ['%s=%r' % (key, value)
14048 
      for key, value in self.__dict__.iteritems()]
14049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14050 
 
14051 
  def __eq__(self, other):
14052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14053 
 
14054 
  def __ne__(self, other):
14055 
    return not (self == other)
14056 
 
14057 
class markOrdersAsLocalConnected_args:
14058 
  """
14059 
  Attributes:
14060 
   - providerId
14061 
   - local_connected_orders
14062 
  """
14063 
 
14064 
  thrift_spec = (
14065 
    None, # 0
14066 
    (1, TType.I64, 'providerId', None, None, ), # 1
14067 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14068 
  )
14069 
 
14070 
  def __init__(self, providerId=None, local_connected_orders=None,):
14071 
    self.providerId = providerId
14072 
    self.local_connected_orders = local_connected_orders
14073 
 
14074 
  def read(self, iprot):
14075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14077 
      return
14078 
    iprot.readStructBegin()
14079 
    while True:
14080 
      (fname, ftype, fid) = iprot.readFieldBegin()
14081 
      if ftype == TType.STOP:
14082 
        break
14083 
      if fid == 1:
14084 
        if ftype == TType.I64:
14085 
          self.providerId = iprot.readI64();
14086 
        else:
14087 
          iprot.skip(ftype)
14088 
      elif fid == 2:
14089 
        if ftype == TType.MAP:
14090 
          self.local_connected_orders = {}
5713 rajveer 14091 
          (_ktype317, _vtype318, _size316 ) = iprot.readMapBegin()
14092 
          for _i320 in xrange(_size316):
14093 
            _key321 = iprot.readString();
14094 
            _val322 = iprot.readString();
14095 
            self.local_connected_orders[_key321] = _val322
4910 phani.kuma 14096 
          iprot.readMapEnd()
14097 
        else:
14098 
          iprot.skip(ftype)
14099 
      else:
14100 
        iprot.skip(ftype)
14101 
      iprot.readFieldEnd()
14102 
    iprot.readStructEnd()
14103 
 
14104 
  def write(self, oprot):
14105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14107 
      return
14108 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
14109 
    if self.providerId is not None:
14110 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14111 
      oprot.writeI64(self.providerId)
14112 
      oprot.writeFieldEnd()
14113 
    if self.local_connected_orders is not None:
14114 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
14115 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5713 rajveer 14116 
      for kiter323,viter324 in self.local_connected_orders.items():
14117 
        oprot.writeString(kiter323)
14118 
        oprot.writeString(viter324)
4910 phani.kuma 14119 
      oprot.writeMapEnd()
14120 
      oprot.writeFieldEnd()
14121 
    oprot.writeFieldStop()
14122 
    oprot.writeStructEnd()
14123 
 
14124 
  def validate(self):
14125 
    return
14126 
 
14127 
 
14128 
  def __repr__(self):
14129 
    L = ['%s=%r' % (key, value)
14130 
      for key, value in self.__dict__.iteritems()]
14131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14132 
 
14133 
  def __eq__(self, other):
14134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14135 
 
14136 
  def __ne__(self, other):
14137 
    return not (self == other)
14138 
 
14139 
class markOrdersAsLocalConnected_result:
14140 
  """
14141 
  Attributes:
14142 
   - ex
14143 
  """
14144 
 
14145 
  thrift_spec = (
14146 
    None, # 0
14147 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14148 
  )
14149 
 
14150 
  def __init__(self, ex=None,):
14151 
    self.ex = ex
14152 
 
14153 
  def read(self, iprot):
14154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14156 
      return
14157 
    iprot.readStructBegin()
14158 
    while True:
14159 
      (fname, ftype, fid) = iprot.readFieldBegin()
14160 
      if ftype == TType.STOP:
14161 
        break
14162 
      if fid == 1:
3064 chandransh 14163 
        if ftype == TType.STRUCT:
14164 
          self.ex = TransactionServiceException()
14165 
          self.ex.read(iprot)
1627 ankur.sing 14166 
        else:
14167 
          iprot.skip(ftype)
14168 
      else:
14169 
        iprot.skip(ftype)
14170 
      iprot.readFieldEnd()
14171 
    iprot.readStructEnd()
14172 
 
14173 
  def write(self, oprot):
14174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14176 
      return
4910 phani.kuma 14177 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
14178 
    if self.ex is not None:
14179 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14180 
      self.ex.write(oprot)
14181 
      oprot.writeFieldEnd()
14182 
    oprot.writeFieldStop()
14183 
    oprot.writeStructEnd()
14184 
 
14185 
  def validate(self):
14186 
    return
14187 
 
14188 
 
14189 
  def __repr__(self):
14190 
    L = ['%s=%r' % (key, value)
14191 
      for key, value in self.__dict__.iteritems()]
14192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14193 
 
14194 
  def __eq__(self, other):
14195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14196 
 
14197 
  def __ne__(self, other):
14198 
    return not (self == other)
14199 
 
14200 
class getOrdersNotLocalConnected_args:
14201 
  """
14202 
  Attributes:
14203 
   - providerId
14204 
  """
14205 
 
14206 
  thrift_spec = (
14207 
    None, # 0
14208 
    (1, TType.I64, 'providerId', None, None, ), # 1
14209 
  )
14210 
 
14211 
  def __init__(self, providerId=None,):
14212 
    self.providerId = providerId
14213 
 
14214 
  def read(self, iprot):
14215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14217 
      return
14218 
    iprot.readStructBegin()
14219 
    while True:
14220 
      (fname, ftype, fid) = iprot.readFieldBegin()
14221 
      if ftype == TType.STOP:
14222 
        break
14223 
      if fid == 1:
14224 
        if ftype == TType.I64:
14225 
          self.providerId = iprot.readI64();
14226 
        else:
14227 
          iprot.skip(ftype)
14228 
      else:
14229 
        iprot.skip(ftype)
14230 
      iprot.readFieldEnd()
14231 
    iprot.readStructEnd()
14232 
 
14233 
  def write(self, oprot):
14234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14236 
      return
14237 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
14238 
    if self.providerId is not None:
14239 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14240 
      oprot.writeI64(self.providerId)
14241 
      oprot.writeFieldEnd()
14242 
    oprot.writeFieldStop()
14243 
    oprot.writeStructEnd()
14244 
 
14245 
  def validate(self):
14246 
    return
14247 
 
14248 
 
14249 
  def __repr__(self):
14250 
    L = ['%s=%r' % (key, value)
14251 
      for key, value in self.__dict__.iteritems()]
14252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14253 
 
14254 
  def __eq__(self, other):
14255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14256 
 
14257 
  def __ne__(self, other):
14258 
    return not (self == other)
14259 
 
14260 
class getOrdersNotLocalConnected_result:
14261 
  """
14262 
  Attributes:
14263 
   - success
14264 
  """
14265 
 
14266 
  thrift_spec = (
14267 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14268 
  )
14269 
 
14270 
  def __init__(self, success=None,):
14271 
    self.success = success
14272 
 
14273 
  def read(self, iprot):
14274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14276 
      return
14277 
    iprot.readStructBegin()
14278 
    while True:
14279 
      (fname, ftype, fid) = iprot.readFieldBegin()
14280 
      if ftype == TType.STOP:
14281 
        break
14282 
      if fid == 0:
14283 
        if ftype == TType.LIST:
14284 
          self.success = []
5713 rajveer 14285 
          (_etype328, _size325) = iprot.readListBegin()
14286 
          for _i329 in xrange(_size325):
14287 
            _elem330 = Order()
14288 
            _elem330.read(iprot)
14289 
            self.success.append(_elem330)
4910 phani.kuma 14290 
          iprot.readListEnd()
14291 
        else:
14292 
          iprot.skip(ftype)
14293 
      else:
14294 
        iprot.skip(ftype)
14295 
      iprot.readFieldEnd()
14296 
    iprot.readStructEnd()
14297 
 
14298 
  def write(self, oprot):
14299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14301 
      return
14302 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 14303 
    if self.success is not None:
14304 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14305 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 14306 
      for iter331 in self.success:
14307 
        iter331.write(oprot)
4581 phani.kuma 14308 
      oprot.writeListEnd()
14309 
      oprot.writeFieldEnd()
4910 phani.kuma 14310 
    oprot.writeFieldStop()
14311 
    oprot.writeStructEnd()
14312 
 
14313 
  def validate(self):
14314 
    return
14315 
 
14316 
 
14317 
  def __repr__(self):
14318 
    L = ['%s=%r' % (key, value)
14319 
      for key, value in self.__dict__.iteritems()]
14320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14321 
 
14322 
  def __eq__(self, other):
14323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14324 
 
14325 
  def __ne__(self, other):
14326 
    return not (self == other)
14327 
 
14328 
class markOrdersAsDestinationCityReached_args:
14329 
  """
14330 
  Attributes:
14331 
   - providerId
14332 
   - destination_city_reached_orders
14333 
  """
14334 
 
14335 
  thrift_spec = (
14336 
    None, # 0
14337 
    (1, TType.I64, 'providerId', None, None, ), # 1
14338 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14339 
  )
14340 
 
14341 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
14342 
    self.providerId = providerId
14343 
    self.destination_city_reached_orders = destination_city_reached_orders
14344 
 
14345 
  def read(self, iprot):
14346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14348 
      return
14349 
    iprot.readStructBegin()
14350 
    while True:
14351 
      (fname, ftype, fid) = iprot.readFieldBegin()
14352 
      if ftype == TType.STOP:
14353 
        break
14354 
      if fid == 1:
14355 
        if ftype == TType.I64:
14356 
          self.providerId = iprot.readI64();
14357 
        else:
14358 
          iprot.skip(ftype)
14359 
      elif fid == 2:
14360 
        if ftype == TType.MAP:
14361 
          self.destination_city_reached_orders = {}
5713 rajveer 14362 
          (_ktype333, _vtype334, _size332 ) = iprot.readMapBegin()
14363 
          for _i336 in xrange(_size332):
14364 
            _key337 = iprot.readString();
14365 
            _val338 = iprot.readString();
14366 
            self.destination_city_reached_orders[_key337] = _val338
4910 phani.kuma 14367 
          iprot.readMapEnd()
14368 
        else:
14369 
          iprot.skip(ftype)
14370 
      else:
14371 
        iprot.skip(ftype)
14372 
      iprot.readFieldEnd()
14373 
    iprot.readStructEnd()
14374 
 
14375 
  def write(self, oprot):
14376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14378 
      return
14379 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
14380 
    if self.providerId is not None:
14381 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14382 
      oprot.writeI64(self.providerId)
14383 
      oprot.writeFieldEnd()
14384 
    if self.destination_city_reached_orders is not None:
14385 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
14386 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5713 rajveer 14387 
      for kiter339,viter340 in self.destination_city_reached_orders.items():
14388 
        oprot.writeString(kiter339)
14389 
        oprot.writeString(viter340)
4910 phani.kuma 14390 
      oprot.writeMapEnd()
14391 
      oprot.writeFieldEnd()
14392 
    oprot.writeFieldStop()
14393 
    oprot.writeStructEnd()
14394 
 
14395 
  def validate(self):
14396 
    return
14397 
 
14398 
 
14399 
  def __repr__(self):
14400 
    L = ['%s=%r' % (key, value)
14401 
      for key, value in self.__dict__.iteritems()]
14402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14403 
 
14404 
  def __eq__(self, other):
14405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14406 
 
14407 
  def __ne__(self, other):
14408 
    return not (self == other)
14409 
 
14410 
class markOrdersAsDestinationCityReached_result:
14411 
  """
14412 
  Attributes:
14413 
   - ex
14414 
  """
14415 
 
14416 
  thrift_spec = (
14417 
    None, # 0
14418 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14419 
  )
14420 
 
14421 
  def __init__(self, ex=None,):
14422 
    self.ex = ex
14423 
 
14424 
  def read(self, iprot):
14425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14427 
      return
14428 
    iprot.readStructBegin()
14429 
    while True:
14430 
      (fname, ftype, fid) = iprot.readFieldBegin()
14431 
      if ftype == TType.STOP:
14432 
        break
14433 
      if fid == 1:
14434 
        if ftype == TType.STRUCT:
14435 
          self.ex = TransactionServiceException()
14436 
          self.ex.read(iprot)
14437 
        else:
14438 
          iprot.skip(ftype)
14439 
      else:
14440 
        iprot.skip(ftype)
14441 
      iprot.readFieldEnd()
14442 
    iprot.readStructEnd()
14443 
 
14444 
  def write(self, oprot):
14445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14447 
      return
14448 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 14449 
    if self.ex is not None:
3064 chandransh 14450 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14451 
      self.ex.write(oprot)
1627 ankur.sing 14452 
      oprot.writeFieldEnd()
14453 
    oprot.writeFieldStop()
14454 
    oprot.writeStructEnd()
14455 
 
3431 rajveer 14456 
  def validate(self):
14457 
    return
14458 
 
14459 
 
1627 ankur.sing 14460 
  def __repr__(self):
14461 
    L = ['%s=%r' % (key, value)
14462 
      for key, value in self.__dict__.iteritems()]
14463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14464 
 
14465 
  def __eq__(self, other):
14466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14467 
 
14468 
  def __ne__(self, other):
14469 
    return not (self == other)
14470 
 
4910 phani.kuma 14471 
class markOrdersAsFirstDeliveryAttempted_args:
14472 
  """
14473 
  Attributes:
14474 
   - providerId
14475 
   - first_atdl_orders
14476 
  """
14477 
 
14478 
  thrift_spec = (
14479 
    None, # 0
14480 
    (1, TType.I64, 'providerId', None, None, ), # 1
14481 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14482 
  )
14483 
 
14484 
  def __init__(self, providerId=None, first_atdl_orders=None,):
14485 
    self.providerId = providerId
14486 
    self.first_atdl_orders = first_atdl_orders
14487 
 
14488 
  def read(self, iprot):
14489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14491 
      return
14492 
    iprot.readStructBegin()
14493 
    while True:
14494 
      (fname, ftype, fid) = iprot.readFieldBegin()
14495 
      if ftype == TType.STOP:
14496 
        break
14497 
      if fid == 1:
14498 
        if ftype == TType.I64:
14499 
          self.providerId = iprot.readI64();
14500 
        else:
14501 
          iprot.skip(ftype)
14502 
      elif fid == 2:
14503 
        if ftype == TType.MAP:
14504 
          self.first_atdl_orders = {}
5713 rajveer 14505 
          (_ktype342, _vtype343, _size341 ) = iprot.readMapBegin()
14506 
          for _i345 in xrange(_size341):
14507 
            _key346 = iprot.readString();
14508 
            _val347 = iprot.readString();
14509 
            self.first_atdl_orders[_key346] = _val347
4910 phani.kuma 14510 
          iprot.readMapEnd()
14511 
        else:
14512 
          iprot.skip(ftype)
14513 
      else:
14514 
        iprot.skip(ftype)
14515 
      iprot.readFieldEnd()
14516 
    iprot.readStructEnd()
14517 
 
14518 
  def write(self, oprot):
14519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14521 
      return
14522 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
14523 
    if self.providerId is not None:
14524 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14525 
      oprot.writeI64(self.providerId)
14526 
      oprot.writeFieldEnd()
14527 
    if self.first_atdl_orders is not None:
14528 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
14529 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5713 rajveer 14530 
      for kiter348,viter349 in self.first_atdl_orders.items():
14531 
        oprot.writeString(kiter348)
14532 
        oprot.writeString(viter349)
4910 phani.kuma 14533 
      oprot.writeMapEnd()
14534 
      oprot.writeFieldEnd()
14535 
    oprot.writeFieldStop()
14536 
    oprot.writeStructEnd()
14537 
 
14538 
  def validate(self):
14539 
    return
14540 
 
14541 
 
14542 
  def __repr__(self):
14543 
    L = ['%s=%r' % (key, value)
14544 
      for key, value in self.__dict__.iteritems()]
14545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14546 
 
14547 
  def __eq__(self, other):
14548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14549 
 
14550 
  def __ne__(self, other):
14551 
    return not (self == other)
14552 
 
14553 
class markOrdersAsFirstDeliveryAttempted_result:
14554 
  """
14555 
  Attributes:
14556 
   - ex
14557 
  """
14558 
 
14559 
  thrift_spec = (
14560 
    None, # 0
14561 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14562 
  )
14563 
 
14564 
  def __init__(self, ex=None,):
14565 
    self.ex = ex
14566 
 
14567 
  def read(self, iprot):
14568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14570 
      return
14571 
    iprot.readStructBegin()
14572 
    while True:
14573 
      (fname, ftype, fid) = iprot.readFieldBegin()
14574 
      if ftype == TType.STOP:
14575 
        break
14576 
      if fid == 1:
14577 
        if ftype == TType.STRUCT:
14578 
          self.ex = TransactionServiceException()
14579 
          self.ex.read(iprot)
14580 
        else:
14581 
          iprot.skip(ftype)
14582 
      else:
14583 
        iprot.skip(ftype)
14584 
      iprot.readFieldEnd()
14585 
    iprot.readStructEnd()
14586 
 
14587 
  def write(self, oprot):
14588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14590 
      return
14591 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
14592 
    if self.ex is not None:
14593 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14594 
      self.ex.write(oprot)
14595 
      oprot.writeFieldEnd()
14596 
    oprot.writeFieldStop()
14597 
    oprot.writeStructEnd()
14598 
 
14599 
  def validate(self):
14600 
    return
14601 
 
14602 
 
14603 
  def __repr__(self):
14604 
    L = ['%s=%r' % (key, value)
14605 
      for key, value in self.__dict__.iteritems()]
14606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14607 
 
14608 
  def __eq__(self, other):
14609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14610 
 
14611 
  def __ne__(self, other):
14612 
    return not (self == other)
14613 
 
3064 chandransh 14614 
class getUndeliveredOrders_args:
1886 ankur.sing 14615 
  """
14616 
  Attributes:
3064 chandransh 14617 
   - providerId
14618 
   - warehouseId
1886 ankur.sing 14619 
  """
1627 ankur.sing 14620 
 
1886 ankur.sing 14621 
  thrift_spec = (
14622 
    None, # 0
3064 chandransh 14623 
    (1, TType.I64, 'providerId', None, None, ), # 1
14624 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 14625 
  )
14626 
 
3064 chandransh 14627 
  def __init__(self, providerId=None, warehouseId=None,):
14628 
    self.providerId = providerId
14629 
    self.warehouseId = warehouseId
1886 ankur.sing 14630 
 
14631 
  def read(self, iprot):
14632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14634 
      return
14635 
    iprot.readStructBegin()
14636 
    while True:
14637 
      (fname, ftype, fid) = iprot.readFieldBegin()
14638 
      if ftype == TType.STOP:
14639 
        break
14640 
      if fid == 1:
14641 
        if ftype == TType.I64:
3064 chandransh 14642 
          self.providerId = iprot.readI64();
1886 ankur.sing 14643 
        else:
14644 
          iprot.skip(ftype)
3064 chandransh 14645 
      elif fid == 2:
14646 
        if ftype == TType.I64:
14647 
          self.warehouseId = iprot.readI64();
14648 
        else:
14649 
          iprot.skip(ftype)
1886 ankur.sing 14650 
      else:
14651 
        iprot.skip(ftype)
14652 
      iprot.readFieldEnd()
14653 
    iprot.readStructEnd()
14654 
 
14655 
  def write(self, oprot):
14656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14658 
      return
3064 chandransh 14659 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 14660 
    if self.providerId is not None:
3064 chandransh 14661 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14662 
      oprot.writeI64(self.providerId)
1886 ankur.sing 14663 
      oprot.writeFieldEnd()
3431 rajveer 14664 
    if self.warehouseId is not None:
3064 chandransh 14665 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14666 
      oprot.writeI64(self.warehouseId)
14667 
      oprot.writeFieldEnd()
1886 ankur.sing 14668 
    oprot.writeFieldStop()
14669 
    oprot.writeStructEnd()
14670 
 
3431 rajveer 14671 
  def validate(self):
14672 
    return
14673 
 
14674 
 
1886 ankur.sing 14675 
  def __repr__(self):
14676 
    L = ['%s=%r' % (key, value)
14677 
      for key, value in self.__dict__.iteritems()]
14678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14679 
 
14680 
  def __eq__(self, other):
14681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14682 
 
14683 
  def __ne__(self, other):
14684 
    return not (self == other)
14685 
 
3064 chandransh 14686 
class getUndeliveredOrders_result:
1886 ankur.sing 14687 
  """
14688 
  Attributes:
14689 
   - success
14690 
  """
14691 
 
14692 
  thrift_spec = (
14693 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14694 
  )
14695 
 
14696 
  def __init__(self, success=None,):
14697 
    self.success = success
14698 
 
14699 
  def read(self, iprot):
14700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14702 
      return
14703 
    iprot.readStructBegin()
14704 
    while True:
14705 
      (fname, ftype, fid) = iprot.readFieldBegin()
14706 
      if ftype == TType.STOP:
14707 
        break
14708 
      if fid == 0:
14709 
        if ftype == TType.LIST:
14710 
          self.success = []
5713 rajveer 14711 
          (_etype353, _size350) = iprot.readListBegin()
14712 
          for _i354 in xrange(_size350):
14713 
            _elem355 = Order()
14714 
            _elem355.read(iprot)
14715 
            self.success.append(_elem355)
1886 ankur.sing 14716 
          iprot.readListEnd()
14717 
        else:
14718 
          iprot.skip(ftype)
14719 
      else:
14720 
        iprot.skip(ftype)
14721 
      iprot.readFieldEnd()
14722 
    iprot.readStructEnd()
14723 
 
14724 
  def write(self, oprot):
14725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14727 
      return
3064 chandransh 14728 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 14729 
    if self.success is not None:
1886 ankur.sing 14730 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14731 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 14732 
      for iter356 in self.success:
14733 
        iter356.write(oprot)
1886 ankur.sing 14734 
      oprot.writeListEnd()
14735 
      oprot.writeFieldEnd()
14736 
    oprot.writeFieldStop()
14737 
    oprot.writeStructEnd()
14738 
 
3431 rajveer 14739 
  def validate(self):
14740 
    return
14741 
 
14742 
 
1886 ankur.sing 14743 
  def __repr__(self):
14744 
    L = ['%s=%r' % (key, value)
14745 
      for key, value in self.__dict__.iteritems()]
14746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14747 
 
14748 
  def __eq__(self, other):
14749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14750 
 
14751 
  def __ne__(self, other):
14752 
    return not (self == other)
14753 
 
4783 phani.kuma 14754 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
14755 
 
14756 
  thrift_spec = (
14757 
  )
14758 
 
14759 
  def read(self, iprot):
14760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14762 
      return
14763 
    iprot.readStructBegin()
14764 
    while True:
14765 
      (fname, ftype, fid) = iprot.readFieldBegin()
14766 
      if ftype == TType.STOP:
14767 
        break
14768 
      else:
14769 
        iprot.skip(ftype)
14770 
      iprot.readFieldEnd()
14771 
    iprot.readStructEnd()
14772 
 
14773 
  def write(self, oprot):
14774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14776 
      return
14777 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
14778 
    oprot.writeFieldStop()
14779 
    oprot.writeStructEnd()
14780 
 
14781 
  def validate(self):
14782 
    return
14783 
 
14784 
 
14785 
  def __repr__(self):
14786 
    L = ['%s=%r' % (key, value)
14787 
      for key, value in self.__dict__.iteritems()]
14788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14789 
 
14790 
  def __eq__(self, other):
14791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14792 
 
14793 
  def __ne__(self, other):
14794 
    return not (self == other)
14795 
 
14796 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
14797 
  """
14798 
  Attributes:
14799 
   - success
14800 
  """
14801 
 
14802 
  thrift_spec = (
14803 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14804 
  )
14805 
 
14806 
  def __init__(self, success=None,):
14807 
    self.success = success
14808 
 
14809 
  def read(self, iprot):
14810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14812 
      return
14813 
    iprot.readStructBegin()
14814 
    while True:
14815 
      (fname, ftype, fid) = iprot.readFieldBegin()
14816 
      if ftype == TType.STOP:
14817 
        break
14818 
      if fid == 0:
14819 
        if ftype == TType.LIST:
14820 
          self.success = []
5713 rajveer 14821 
          (_etype360, _size357) = iprot.readListBegin()
14822 
          for _i361 in xrange(_size357):
14823 
            _elem362 = Order()
14824 
            _elem362.read(iprot)
14825 
            self.success.append(_elem362)
4783 phani.kuma 14826 
          iprot.readListEnd()
14827 
        else:
14828 
          iprot.skip(ftype)
14829 
      else:
14830 
        iprot.skip(ftype)
14831 
      iprot.readFieldEnd()
14832 
    iprot.readStructEnd()
14833 
 
14834 
  def write(self, oprot):
14835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14837 
      return
14838 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
14839 
    if self.success is not None:
14840 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14841 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 14842 
      for iter363 in self.success:
14843 
        iter363.write(oprot)
4783 phani.kuma 14844 
      oprot.writeListEnd()
14845 
      oprot.writeFieldEnd()
14846 
    oprot.writeFieldStop()
14847 
    oprot.writeStructEnd()
14848 
 
14849 
  def validate(self):
14850 
    return
14851 
 
14852 
 
14853 
  def __repr__(self):
14854 
    L = ['%s=%r' % (key, value)
14855 
      for key, value in self.__dict__.iteritems()]
14856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14857 
 
14858 
  def __eq__(self, other):
14859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14860 
 
14861 
  def __ne__(self, other):
14862 
    return not (self == other)
14863 
 
2536 chandransh 14864 
class toggleDOAFlag_args:
14865 
  """
14866 
  Attributes:
14867 
   - orderId
14868 
  """
1886 ankur.sing 14869 
 
2536 chandransh 14870 
  thrift_spec = (
14871 
    None, # 0
14872 
    (1, TType.I64, 'orderId', None, None, ), # 1
14873 
  )
14874 
 
14875 
  def __init__(self, orderId=None,):
14876 
    self.orderId = orderId
14877 
 
14878 
  def read(self, iprot):
14879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14881 
      return
14882 
    iprot.readStructBegin()
14883 
    while True:
14884 
      (fname, ftype, fid) = iprot.readFieldBegin()
14885 
      if ftype == TType.STOP:
14886 
        break
14887 
      if fid == 1:
14888 
        if ftype == TType.I64:
14889 
          self.orderId = iprot.readI64();
14890 
        else:
14891 
          iprot.skip(ftype)
14892 
      else:
14893 
        iprot.skip(ftype)
14894 
      iprot.readFieldEnd()
14895 
    iprot.readStructEnd()
14896 
 
14897 
  def write(self, oprot):
14898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14900 
      return
14901 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 14902 
    if self.orderId is not None:
2536 chandransh 14903 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14904 
      oprot.writeI64(self.orderId)
14905 
      oprot.writeFieldEnd()
14906 
    oprot.writeFieldStop()
14907 
    oprot.writeStructEnd()
14908 
 
3431 rajveer 14909 
  def validate(self):
14910 
    return
14911 
 
14912 
 
2536 chandransh 14913 
  def __repr__(self):
14914 
    L = ['%s=%r' % (key, value)
14915 
      for key, value in self.__dict__.iteritems()]
14916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14917 
 
14918 
  def __eq__(self, other):
14919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14920 
 
14921 
  def __ne__(self, other):
14922 
    return not (self == other)
14923 
 
14924 
class toggleDOAFlag_result:
14925 
  """
14926 
  Attributes:
14927 
   - success
14928 
   - ex
14929 
  """
14930 
 
14931 
  thrift_spec = (
14932 
    (0, TType.BOOL, 'success', None, None, ), # 0
14933 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14934 
  )
14935 
 
14936 
  def __init__(self, success=None, ex=None,):
14937 
    self.success = success
14938 
    self.ex = ex
14939 
 
14940 
  def read(self, iprot):
14941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14943 
      return
14944 
    iprot.readStructBegin()
14945 
    while True:
14946 
      (fname, ftype, fid) = iprot.readFieldBegin()
14947 
      if ftype == TType.STOP:
14948 
        break
14949 
      if fid == 0:
14950 
        if ftype == TType.BOOL:
14951 
          self.success = iprot.readBool();
14952 
        else:
14953 
          iprot.skip(ftype)
14954 
      elif fid == 1:
14955 
        if ftype == TType.STRUCT:
14956 
          self.ex = TransactionServiceException()
14957 
          self.ex.read(iprot)
14958 
        else:
14959 
          iprot.skip(ftype)
14960 
      else:
14961 
        iprot.skip(ftype)
14962 
      iprot.readFieldEnd()
14963 
    iprot.readStructEnd()
14964 
 
14965 
  def write(self, oprot):
14966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14968 
      return
14969 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 14970 
    if self.success is not None:
2536 chandransh 14971 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14972 
      oprot.writeBool(self.success)
14973 
      oprot.writeFieldEnd()
3431 rajveer 14974 
    if self.ex is not None:
2536 chandransh 14975 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14976 
      self.ex.write(oprot)
14977 
      oprot.writeFieldEnd()
14978 
    oprot.writeFieldStop()
14979 
    oprot.writeStructEnd()
14980 
 
3431 rajveer 14981 
  def validate(self):
14982 
    return
14983 
 
14984 
 
2536 chandransh 14985 
  def __repr__(self):
14986 
    L = ['%s=%r' % (key, value)
14987 
      for key, value in self.__dict__.iteritems()]
14988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14989 
 
14990 
  def __eq__(self, other):
14991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14992 
 
14993 
  def __ne__(self, other):
14994 
    return not (self == other)
14995 
 
4712 rajveer 14996 
class markOrderAsDelivered_args:
14997 
  """
14998 
  Attributes:
14999 
   - orderId
15000 
   - deliveryTimestamp
15001 
   - receiver
15002 
  """
15003 
 
15004 
  thrift_spec = None
15005 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
15006 
    self.orderId = orderId
15007 
    self.deliveryTimestamp = deliveryTimestamp
15008 
    self.receiver = receiver
15009 
 
15010 
  def read(self, iprot):
15011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15013 
      return
15014 
    iprot.readStructBegin()
15015 
    while True:
15016 
      (fname, ftype, fid) = iprot.readFieldBegin()
15017 
      if ftype == TType.STOP:
15018 
        break
15019 
      if fid == 1:
15020 
        if ftype == TType.I64:
15021 
          self.orderId = iprot.readI64();
15022 
        else:
15023 
          iprot.skip(ftype)
15024 
      elif fid == 2:
15025 
        if ftype == TType.I64:
15026 
          self.deliveryTimestamp = iprot.readI64();
15027 
        else:
15028 
          iprot.skip(ftype)
15029 
      elif fid == -1:
15030 
        if ftype == TType.STRING:
15031 
          self.receiver = iprot.readString();
15032 
        else:
15033 
          iprot.skip(ftype)
15034 
      else:
15035 
        iprot.skip(ftype)
15036 
      iprot.readFieldEnd()
15037 
    iprot.readStructEnd()
15038 
 
15039 
  def write(self, oprot):
15040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15042 
      return
15043 
    oprot.writeStructBegin('markOrderAsDelivered_args')
15044 
    if self.receiver is not None:
15045 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
15046 
      oprot.writeString(self.receiver)
15047 
      oprot.writeFieldEnd()
15048 
    if self.orderId is not None:
15049 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15050 
      oprot.writeI64(self.orderId)
15051 
      oprot.writeFieldEnd()
15052 
    if self.deliveryTimestamp is not None:
15053 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15054 
      oprot.writeI64(self.deliveryTimestamp)
15055 
      oprot.writeFieldEnd()
15056 
    oprot.writeFieldStop()
15057 
    oprot.writeStructEnd()
15058 
 
15059 
  def validate(self):
15060 
    return
15061 
 
15062 
 
15063 
  def __repr__(self):
15064 
    L = ['%s=%r' % (key, value)
15065 
      for key, value in self.__dict__.iteritems()]
15066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15067 
 
15068 
  def __eq__(self, other):
15069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15070 
 
15071 
  def __ne__(self, other):
15072 
    return not (self == other)
15073 
 
15074 
class markOrderAsDelivered_result:
15075 
  """
15076 
  Attributes:
15077 
   - ex
15078 
  """
15079 
 
15080 
  thrift_spec = (
15081 
    None, # 0
15082 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15083 
  )
15084 
 
15085 
  def __init__(self, ex=None,):
15086 
    self.ex = ex
15087 
 
15088 
  def read(self, iprot):
15089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15091 
      return
15092 
    iprot.readStructBegin()
15093 
    while True:
15094 
      (fname, ftype, fid) = iprot.readFieldBegin()
15095 
      if ftype == TType.STOP:
15096 
        break
15097 
      if fid == 1:
15098 
        if ftype == TType.STRUCT:
15099 
          self.ex = TransactionServiceException()
15100 
          self.ex.read(iprot)
15101 
        else:
15102 
          iprot.skip(ftype)
15103 
      else:
15104 
        iprot.skip(ftype)
15105 
      iprot.readFieldEnd()
15106 
    iprot.readStructEnd()
15107 
 
15108 
  def write(self, oprot):
15109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15111 
      return
15112 
    oprot.writeStructBegin('markOrderAsDelivered_result')
15113 
    if self.ex is not None:
15114 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15115 
      self.ex.write(oprot)
15116 
      oprot.writeFieldEnd()
15117 
    oprot.writeFieldStop()
15118 
    oprot.writeStructEnd()
15119 
 
15120 
  def validate(self):
15121 
    return
15122 
 
15123 
 
15124 
  def __repr__(self):
15125 
    L = ['%s=%r' % (key, value)
15126 
      for key, value in self.__dict__.iteritems()]
15127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15128 
 
15129 
  def __eq__(self, other):
15130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15131 
 
15132 
  def __ne__(self, other):
15133 
    return not (self == other)
15134 
 
5553 rajveer 15135 
class markOrderAsReceivedAtStore_args:
15136 
  """
15137 
  Attributes:
15138 
   - orderId
15139 
   - deliveryTimestamp
15140 
  """
15141 
 
15142 
  thrift_spec = (
15143 
    None, # 0
15144 
    (1, TType.I64, 'orderId', None, None, ), # 1
15145 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
15146 
  )
15147 
 
15148 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
15149 
    self.orderId = orderId
15150 
    self.deliveryTimestamp = deliveryTimestamp
15151 
 
15152 
  def read(self, iprot):
15153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15155 
      return
15156 
    iprot.readStructBegin()
15157 
    while True:
15158 
      (fname, ftype, fid) = iprot.readFieldBegin()
15159 
      if ftype == TType.STOP:
15160 
        break
15161 
      if fid == 1:
15162 
        if ftype == TType.I64:
15163 
          self.orderId = iprot.readI64();
15164 
        else:
15165 
          iprot.skip(ftype)
15166 
      elif fid == 2:
15167 
        if ftype == TType.I64:
15168 
          self.deliveryTimestamp = iprot.readI64();
15169 
        else:
15170 
          iprot.skip(ftype)
15171 
      else:
15172 
        iprot.skip(ftype)
15173 
      iprot.readFieldEnd()
15174 
    iprot.readStructEnd()
15175 
 
15176 
  def write(self, oprot):
15177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15179 
      return
15180 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
15181 
    if self.orderId is not None:
15182 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15183 
      oprot.writeI64(self.orderId)
15184 
      oprot.writeFieldEnd()
15185 
    if self.deliveryTimestamp is not None:
15186 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15187 
      oprot.writeI64(self.deliveryTimestamp)
15188 
      oprot.writeFieldEnd()
15189 
    oprot.writeFieldStop()
15190 
    oprot.writeStructEnd()
15191 
 
15192 
  def validate(self):
15193 
    return
15194 
 
15195 
 
15196 
  def __repr__(self):
15197 
    L = ['%s=%r' % (key, value)
15198 
      for key, value in self.__dict__.iteritems()]
15199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15200 
 
15201 
  def __eq__(self, other):
15202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15203 
 
15204 
  def __ne__(self, other):
15205 
    return not (self == other)
15206 
 
15207 
class markOrderAsReceivedAtStore_result:
15208 
  """
15209 
  Attributes:
15210 
   - ex
15211 
  """
15212 
 
15213 
  thrift_spec = (
15214 
    None, # 0
15215 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15216 
  )
15217 
 
15218 
  def __init__(self, ex=None,):
15219 
    self.ex = ex
15220 
 
15221 
  def read(self, iprot):
15222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15224 
      return
15225 
    iprot.readStructBegin()
15226 
    while True:
15227 
      (fname, ftype, fid) = iprot.readFieldBegin()
15228 
      if ftype == TType.STOP:
15229 
        break
15230 
      if fid == 1:
15231 
        if ftype == TType.STRUCT:
15232 
          self.ex = TransactionServiceException()
15233 
          self.ex.read(iprot)
15234 
        else:
15235 
          iprot.skip(ftype)
15236 
      else:
15237 
        iprot.skip(ftype)
15238 
      iprot.readFieldEnd()
15239 
    iprot.readStructEnd()
15240 
 
15241 
  def write(self, oprot):
15242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15244 
      return
15245 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
15246 
    if self.ex is not None:
15247 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15248 
      self.ex.write(oprot)
15249 
      oprot.writeFieldEnd()
15250 
    oprot.writeFieldStop()
15251 
    oprot.writeStructEnd()
15252 
 
15253 
  def validate(self):
15254 
    return
15255 
 
15256 
 
15257 
  def __repr__(self):
15258 
    L = ['%s=%r' % (key, value)
15259 
      for key, value in self.__dict__.iteritems()]
15260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15261 
 
15262 
  def __eq__(self, other):
15263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15264 
 
15265 
  def __ne__(self, other):
15266 
    return not (self == other)
15267 
 
4454 rajveer 15268 
class markOrderDoaRequestReceived_args:
15269 
  """
15270 
  Attributes:
15271 
   - orderId
15272 
  """
15273 
 
15274 
  thrift_spec = (
15275 
    None, # 0
15276 
    (1, TType.I64, 'orderId', None, None, ), # 1
15277 
  )
15278 
 
15279 
  def __init__(self, orderId=None,):
15280 
    self.orderId = orderId
15281 
 
15282 
  def read(self, iprot):
15283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15285 
      return
15286 
    iprot.readStructBegin()
15287 
    while True:
15288 
      (fname, ftype, fid) = iprot.readFieldBegin()
15289 
      if ftype == TType.STOP:
15290 
        break
15291 
      if fid == 1:
15292 
        if ftype == TType.I64:
15293 
          self.orderId = iprot.readI64();
15294 
        else:
15295 
          iprot.skip(ftype)
15296 
      else:
15297 
        iprot.skip(ftype)
15298 
      iprot.readFieldEnd()
15299 
    iprot.readStructEnd()
15300 
 
15301 
  def write(self, oprot):
15302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15304 
      return
15305 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
15306 
    if self.orderId is not None:
15307 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15308 
      oprot.writeI64(self.orderId)
15309 
      oprot.writeFieldEnd()
15310 
    oprot.writeFieldStop()
15311 
    oprot.writeStructEnd()
15312 
 
15313 
  def validate(self):
15314 
    return
15315 
 
15316 
 
15317 
  def __repr__(self):
15318 
    L = ['%s=%r' % (key, value)
15319 
      for key, value in self.__dict__.iteritems()]
15320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15321 
 
15322 
  def __eq__(self, other):
15323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15324 
 
15325 
  def __ne__(self, other):
15326 
    return not (self == other)
15327 
 
15328 
class markOrderDoaRequestReceived_result:
15329 
  """
15330 
  Attributes:
15331 
   - success
15332 
   - ex
15333 
  """
15334 
 
15335 
  thrift_spec = (
15336 
    (0, TType.BOOL, 'success', None, None, ), # 0
15337 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15338 
  )
15339 
 
15340 
  def __init__(self, success=None, ex=None,):
15341 
    self.success = success
15342 
    self.ex = ex
15343 
 
15344 
  def read(self, iprot):
15345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15347 
      return
15348 
    iprot.readStructBegin()
15349 
    while True:
15350 
      (fname, ftype, fid) = iprot.readFieldBegin()
15351 
      if ftype == TType.STOP:
15352 
        break
15353 
      if fid == 0:
15354 
        if ftype == TType.BOOL:
15355 
          self.success = iprot.readBool();
15356 
        else:
15357 
          iprot.skip(ftype)
15358 
      elif fid == 1:
15359 
        if ftype == TType.STRUCT:
15360 
          self.ex = TransactionServiceException()
15361 
          self.ex.read(iprot)
15362 
        else:
15363 
          iprot.skip(ftype)
15364 
      else:
15365 
        iprot.skip(ftype)
15366 
      iprot.readFieldEnd()
15367 
    iprot.readStructEnd()
15368 
 
15369 
  def write(self, oprot):
15370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15372 
      return
15373 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
15374 
    if self.success is not None:
15375 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15376 
      oprot.writeBool(self.success)
15377 
      oprot.writeFieldEnd()
15378 
    if self.ex is not None:
15379 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15380 
      self.ex.write(oprot)
15381 
      oprot.writeFieldEnd()
15382 
    oprot.writeFieldStop()
15383 
    oprot.writeStructEnd()
15384 
 
15385 
  def validate(self):
15386 
    return
15387 
 
15388 
 
15389 
  def __repr__(self):
15390 
    L = ['%s=%r' % (key, value)
15391 
      for key, value in self.__dict__.iteritems()]
15392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15393 
 
15394 
  def __eq__(self, other):
15395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15396 
 
15397 
  def __ne__(self, other):
15398 
    return not (self == other)
15399 
 
15400 
class markOrderDoaRequestAuthorized_args:
15401 
  """
15402 
  Attributes:
15403 
   - orderId
15404 
   - isAuthorized
15405 
  """
15406 
 
15407 
  thrift_spec = (
15408 
    None, # 0
15409 
    (1, TType.I64, 'orderId', None, None, ), # 1
15410 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
15411 
  )
15412 
 
15413 
  def __init__(self, orderId=None, isAuthorized=None,):
15414 
    self.orderId = orderId
15415 
    self.isAuthorized = isAuthorized
15416 
 
15417 
  def read(self, iprot):
15418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15420 
      return
15421 
    iprot.readStructBegin()
15422 
    while True:
15423 
      (fname, ftype, fid) = iprot.readFieldBegin()
15424 
      if ftype == TType.STOP:
15425 
        break
15426 
      if fid == 1:
15427 
        if ftype == TType.I64:
15428 
          self.orderId = iprot.readI64();
15429 
        else:
15430 
          iprot.skip(ftype)
15431 
      elif fid == 2:
15432 
        if ftype == TType.BOOL:
15433 
          self.isAuthorized = iprot.readBool();
15434 
        else:
15435 
          iprot.skip(ftype)
15436 
      else:
15437 
        iprot.skip(ftype)
15438 
      iprot.readFieldEnd()
15439 
    iprot.readStructEnd()
15440 
 
15441 
  def write(self, oprot):
15442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15444 
      return
15445 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
15446 
    if self.orderId is not None:
15447 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15448 
      oprot.writeI64(self.orderId)
15449 
      oprot.writeFieldEnd()
15450 
    if self.isAuthorized is not None:
15451 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
15452 
      oprot.writeBool(self.isAuthorized)
15453 
      oprot.writeFieldEnd()
15454 
    oprot.writeFieldStop()
15455 
    oprot.writeStructEnd()
15456 
 
15457 
  def validate(self):
15458 
    return
15459 
 
15460 
 
15461 
  def __repr__(self):
15462 
    L = ['%s=%r' % (key, value)
15463 
      for key, value in self.__dict__.iteritems()]
15464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15465 
 
15466 
  def __eq__(self, other):
15467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15468 
 
15469 
  def __ne__(self, other):
15470 
    return not (self == other)
15471 
 
15472 
class markOrderDoaRequestAuthorized_result:
15473 
  """
15474 
  Attributes:
15475 
   - success
15476 
   - ex
15477 
  """
15478 
 
15479 
  thrift_spec = (
15480 
    (0, TType.BOOL, 'success', None, None, ), # 0
15481 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15482 
  )
15483 
 
15484 
  def __init__(self, success=None, ex=None,):
15485 
    self.success = success
15486 
    self.ex = ex
15487 
 
15488 
  def read(self, iprot):
15489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15491 
      return
15492 
    iprot.readStructBegin()
15493 
    while True:
15494 
      (fname, ftype, fid) = iprot.readFieldBegin()
15495 
      if ftype == TType.STOP:
15496 
        break
15497 
      if fid == 0:
15498 
        if ftype == TType.BOOL:
15499 
          self.success = iprot.readBool();
15500 
        else:
15501 
          iprot.skip(ftype)
15502 
      elif fid == 1:
15503 
        if ftype == TType.STRUCT:
15504 
          self.ex = TransactionServiceException()
15505 
          self.ex.read(iprot)
15506 
        else:
15507 
          iprot.skip(ftype)
15508 
      else:
15509 
        iprot.skip(ftype)
15510 
      iprot.readFieldEnd()
15511 
    iprot.readStructEnd()
15512 
 
15513 
  def write(self, oprot):
15514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15516 
      return
15517 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
15518 
    if self.success is not None:
15519 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15520 
      oprot.writeBool(self.success)
15521 
      oprot.writeFieldEnd()
15522 
    if self.ex is not None:
15523 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15524 
      self.ex.write(oprot)
15525 
      oprot.writeFieldEnd()
15526 
    oprot.writeFieldStop()
15527 
    oprot.writeStructEnd()
15528 
 
15529 
  def validate(self):
15530 
    return
15531 
 
15532 
 
15533 
  def __repr__(self):
15534 
    L = ['%s=%r' % (key, value)
15535 
      for key, value in self.__dict__.iteritems()]
15536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15537 
 
15538 
  def __eq__(self, other):
15539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15540 
 
15541 
  def __ne__(self, other):
15542 
    return not (self == other)
15543 
 
4488 rajveer 15544 
class markOrderReturnRequestReceived_args:
15545 
  """
15546 
  Attributes:
15547 
   - orderId
15548 
  """
15549 
 
15550 
  thrift_spec = (
15551 
    None, # 0
15552 
    (1, TType.I64, 'orderId', None, None, ), # 1
15553 
  )
15554 
 
15555 
  def __init__(self, orderId=None,):
15556 
    self.orderId = orderId
15557 
 
15558 
  def read(self, iprot):
15559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15561 
      return
15562 
    iprot.readStructBegin()
15563 
    while True:
15564 
      (fname, ftype, fid) = iprot.readFieldBegin()
15565 
      if ftype == TType.STOP:
15566 
        break
15567 
      if fid == 1:
15568 
        if ftype == TType.I64:
15569 
          self.orderId = iprot.readI64();
15570 
        else:
15571 
          iprot.skip(ftype)
15572 
      else:
15573 
        iprot.skip(ftype)
15574 
      iprot.readFieldEnd()
15575 
    iprot.readStructEnd()
15576 
 
15577 
  def write(self, oprot):
15578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15580 
      return
15581 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
15582 
    if self.orderId is not None:
15583 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15584 
      oprot.writeI64(self.orderId)
15585 
      oprot.writeFieldEnd()
15586 
    oprot.writeFieldStop()
15587 
    oprot.writeStructEnd()
15588 
 
15589 
  def validate(self):
15590 
    return
15591 
 
15592 
 
15593 
  def __repr__(self):
15594 
    L = ['%s=%r' % (key, value)
15595 
      for key, value in self.__dict__.iteritems()]
15596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15597 
 
15598 
  def __eq__(self, other):
15599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15600 
 
15601 
  def __ne__(self, other):
15602 
    return not (self == other)
15603 
 
15604 
class markOrderReturnRequestReceived_result:
15605 
  """
15606 
  Attributes:
15607 
   - success
15608 
   - ex
15609 
  """
15610 
 
15611 
  thrift_spec = (
15612 
    (0, TType.BOOL, 'success', None, None, ), # 0
15613 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15614 
  )
15615 
 
15616 
  def __init__(self, success=None, ex=None,):
15617 
    self.success = success
15618 
    self.ex = ex
15619 
 
15620 
  def read(self, iprot):
15621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15623 
      return
15624 
    iprot.readStructBegin()
15625 
    while True:
15626 
      (fname, ftype, fid) = iprot.readFieldBegin()
15627 
      if ftype == TType.STOP:
15628 
        break
15629 
      if fid == 0:
15630 
        if ftype == TType.BOOL:
15631 
          self.success = iprot.readBool();
15632 
        else:
15633 
          iprot.skip(ftype)
15634 
      elif fid == 1:
15635 
        if ftype == TType.STRUCT:
15636 
          self.ex = TransactionServiceException()
15637 
          self.ex.read(iprot)
15638 
        else:
15639 
          iprot.skip(ftype)
15640 
      else:
15641 
        iprot.skip(ftype)
15642 
      iprot.readFieldEnd()
15643 
    iprot.readStructEnd()
15644 
 
15645 
  def write(self, oprot):
15646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15648 
      return
15649 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
15650 
    if self.success is not None:
15651 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15652 
      oprot.writeBool(self.success)
15653 
      oprot.writeFieldEnd()
15654 
    if self.ex is not None:
15655 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15656 
      self.ex.write(oprot)
15657 
      oprot.writeFieldEnd()
15658 
    oprot.writeFieldStop()
15659 
    oprot.writeStructEnd()
15660 
 
15661 
  def validate(self):
15662 
    return
15663 
 
15664 
 
15665 
  def __repr__(self):
15666 
    L = ['%s=%r' % (key, value)
15667 
      for key, value in self.__dict__.iteritems()]
15668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15669 
 
15670 
  def __eq__(self, other):
15671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15672 
 
15673 
  def __ne__(self, other):
15674 
    return not (self == other)
15675 
 
15676 
class markOrderReturnRequestAuthorized_args:
15677 
  """
15678 
  Attributes:
15679 
   - orderId
15680 
   - isAuthorized
15681 
  """
15682 
 
15683 
  thrift_spec = (
15684 
    None, # 0
15685 
    (1, TType.I64, 'orderId', None, None, ), # 1
15686 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
15687 
  )
15688 
 
15689 
  def __init__(self, orderId=None, isAuthorized=None,):
15690 
    self.orderId = orderId
15691 
    self.isAuthorized = isAuthorized
15692 
 
15693 
  def read(self, iprot):
15694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15696 
      return
15697 
    iprot.readStructBegin()
15698 
    while True:
15699 
      (fname, ftype, fid) = iprot.readFieldBegin()
15700 
      if ftype == TType.STOP:
15701 
        break
15702 
      if fid == 1:
15703 
        if ftype == TType.I64:
15704 
          self.orderId = iprot.readI64();
15705 
        else:
15706 
          iprot.skip(ftype)
15707 
      elif fid == 2:
15708 
        if ftype == TType.BOOL:
15709 
          self.isAuthorized = iprot.readBool();
15710 
        else:
15711 
          iprot.skip(ftype)
15712 
      else:
15713 
        iprot.skip(ftype)
15714 
      iprot.readFieldEnd()
15715 
    iprot.readStructEnd()
15716 
 
15717 
  def write(self, oprot):
15718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15720 
      return
15721 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
15722 
    if self.orderId is not None:
15723 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15724 
      oprot.writeI64(self.orderId)
15725 
      oprot.writeFieldEnd()
15726 
    if self.isAuthorized is not None:
15727 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
15728 
      oprot.writeBool(self.isAuthorized)
15729 
      oprot.writeFieldEnd()
15730 
    oprot.writeFieldStop()
15731 
    oprot.writeStructEnd()
15732 
 
15733 
  def validate(self):
15734 
    return
15735 
 
15736 
 
15737 
  def __repr__(self):
15738 
    L = ['%s=%r' % (key, value)
15739 
      for key, value in self.__dict__.iteritems()]
15740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15741 
 
15742 
  def __eq__(self, other):
15743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15744 
 
15745 
  def __ne__(self, other):
15746 
    return not (self == other)
15747 
 
15748 
class markOrderReturnRequestAuthorized_result:
15749 
  """
15750 
  Attributes:
15751 
   - success
15752 
   - ex
15753 
  """
15754 
 
15755 
  thrift_spec = (
15756 
    (0, TType.BOOL, 'success', None, None, ), # 0
15757 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15758 
  )
15759 
 
15760 
  def __init__(self, success=None, ex=None,):
15761 
    self.success = success
15762 
    self.ex = ex
15763 
 
15764 
  def read(self, iprot):
15765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15767 
      return
15768 
    iprot.readStructBegin()
15769 
    while True:
15770 
      (fname, ftype, fid) = iprot.readFieldBegin()
15771 
      if ftype == TType.STOP:
15772 
        break
15773 
      if fid == 0:
15774 
        if ftype == TType.BOOL:
15775 
          self.success = iprot.readBool();
15776 
        else:
15777 
          iprot.skip(ftype)
15778 
      elif fid == 1:
15779 
        if ftype == TType.STRUCT:
15780 
          self.ex = TransactionServiceException()
15781 
          self.ex.read(iprot)
15782 
        else:
15783 
          iprot.skip(ftype)
15784 
      else:
15785 
        iprot.skip(ftype)
15786 
      iprot.readFieldEnd()
15787 
    iprot.readStructEnd()
15788 
 
15789 
  def write(self, oprot):
15790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15792 
      return
15793 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
15794 
    if self.success is not None:
15795 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15796 
      oprot.writeBool(self.success)
15797 
      oprot.writeFieldEnd()
15798 
    if self.ex is not None:
15799 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15800 
      self.ex.write(oprot)
15801 
      oprot.writeFieldEnd()
15802 
    oprot.writeFieldStop()
15803 
    oprot.writeStructEnd()
15804 
 
15805 
  def validate(self):
15806 
    return
15807 
 
15808 
 
15809 
  def __repr__(self):
15810 
    L = ['%s=%r' % (key, value)
15811 
      for key, value in self.__dict__.iteritems()]
15812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15813 
 
15814 
  def __eq__(self, other):
15815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15816 
 
15817 
  def __ne__(self, other):
15818 
    return not (self == other)
15819 
 
2536 chandransh 15820 
class requestPickupNumber_args:
15821 
  """
15822 
  Attributes:
15823 
   - orderId
4579 rajveer 15824 
   - providerId
2536 chandransh 15825 
  """
15826 
 
15827 
  thrift_spec = (
15828 
    None, # 0
15829 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 15830 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 15831 
  )
15832 
 
4579 rajveer 15833 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 15834 
    self.orderId = orderId
4579 rajveer 15835 
    self.providerId = providerId
2536 chandransh 15836 
 
15837 
  def read(self, iprot):
15838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15840 
      return
15841 
    iprot.readStructBegin()
15842 
    while True:
15843 
      (fname, ftype, fid) = iprot.readFieldBegin()
15844 
      if ftype == TType.STOP:
15845 
        break
15846 
      if fid == 1:
15847 
        if ftype == TType.I64:
15848 
          self.orderId = iprot.readI64();
15849 
        else:
15850 
          iprot.skip(ftype)
4579 rajveer 15851 
      elif fid == 2:
15852 
        if ftype == TType.I64:
15853 
          self.providerId = iprot.readI64();
15854 
        else:
15855 
          iprot.skip(ftype)
2536 chandransh 15856 
      else:
15857 
        iprot.skip(ftype)
15858 
      iprot.readFieldEnd()
15859 
    iprot.readStructEnd()
15860 
 
15861 
  def write(self, oprot):
15862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15864 
      return
15865 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 15866 
    if self.orderId is not None:
2536 chandransh 15867 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15868 
      oprot.writeI64(self.orderId)
15869 
      oprot.writeFieldEnd()
4579 rajveer 15870 
    if self.providerId is not None:
15871 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
15872 
      oprot.writeI64(self.providerId)
15873 
      oprot.writeFieldEnd()
2536 chandransh 15874 
    oprot.writeFieldStop()
15875 
    oprot.writeStructEnd()
15876 
 
3431 rajveer 15877 
  def validate(self):
15878 
    return
15879 
 
15880 
 
2536 chandransh 15881 
  def __repr__(self):
15882 
    L = ['%s=%r' % (key, value)
15883 
      for key, value in self.__dict__.iteritems()]
15884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15885 
 
15886 
  def __eq__(self, other):
15887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15888 
 
15889 
  def __ne__(self, other):
15890 
    return not (self == other)
15891 
 
15892 
class requestPickupNumber_result:
15893 
  """
15894 
  Attributes:
15895 
   - success
15896 
   - ex
15897 
  """
15898 
 
15899 
  thrift_spec = (
15900 
    (0, TType.BOOL, 'success', None, None, ), # 0
15901 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15902 
  )
15903 
 
15904 
  def __init__(self, success=None, ex=None,):
15905 
    self.success = success
15906 
    self.ex = ex
15907 
 
15908 
  def read(self, iprot):
15909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15911 
      return
15912 
    iprot.readStructBegin()
15913 
    while True:
15914 
      (fname, ftype, fid) = iprot.readFieldBegin()
15915 
      if ftype == TType.STOP:
15916 
        break
15917 
      if fid == 0:
15918 
        if ftype == TType.BOOL:
15919 
          self.success = iprot.readBool();
15920 
        else:
15921 
          iprot.skip(ftype)
15922 
      elif fid == 1:
15923 
        if ftype == TType.STRUCT:
15924 
          self.ex = TransactionServiceException()
15925 
          self.ex.read(iprot)
15926 
        else:
15927 
          iprot.skip(ftype)
15928 
      else:
15929 
        iprot.skip(ftype)
15930 
      iprot.readFieldEnd()
15931 
    iprot.readStructEnd()
15932 
 
15933 
  def write(self, oprot):
15934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15936 
      return
15937 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 15938 
    if self.success is not None:
2536 chandransh 15939 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15940 
      oprot.writeBool(self.success)
15941 
      oprot.writeFieldEnd()
3431 rajveer 15942 
    if self.ex is not None:
2536 chandransh 15943 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15944 
      self.ex.write(oprot)
15945 
      oprot.writeFieldEnd()
15946 
    oprot.writeFieldStop()
15947 
    oprot.writeStructEnd()
15948 
 
3431 rajveer 15949 
  def validate(self):
15950 
    return
15951 
 
15952 
 
2536 chandransh 15953 
  def __repr__(self):
15954 
    L = ['%s=%r' % (key, value)
15955 
      for key, value in self.__dict__.iteritems()]
15956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15957 
 
15958 
  def __eq__(self, other):
15959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15960 
 
15961 
  def __ne__(self, other):
15962 
    return not (self == other)
15963 
 
15964 
class authorizePickup_args:
15965 
  """
15966 
  Attributes:
15967 
   - orderId
15968 
   - pickupNumber
4602 rajveer 15969 
   - providerId
2536 chandransh 15970 
  """
15971 
 
15972 
  thrift_spec = (
15973 
    None, # 0
15974 
    (1, TType.I64, 'orderId', None, None, ), # 1
15975 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 15976 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 15977 
  )
15978 
 
4602 rajveer 15979 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 15980 
    self.orderId = orderId
15981 
    self.pickupNumber = pickupNumber
4602 rajveer 15982 
    self.providerId = providerId
2536 chandransh 15983 
 
15984 
  def read(self, iprot):
15985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15987 
      return
15988 
    iprot.readStructBegin()
15989 
    while True:
15990 
      (fname, ftype, fid) = iprot.readFieldBegin()
15991 
      if ftype == TType.STOP:
15992 
        break
15993 
      if fid == 1:
15994 
        if ftype == TType.I64:
15995 
          self.orderId = iprot.readI64();
15996 
        else:
15997 
          iprot.skip(ftype)
15998 
      elif fid == 2:
15999 
        if ftype == TType.STRING:
16000 
          self.pickupNumber = iprot.readString();
16001 
        else:
16002 
          iprot.skip(ftype)
4602 rajveer 16003 
      elif fid == 3:
16004 
        if ftype == TType.I64:
16005 
          self.providerId = iprot.readI64();
16006 
        else:
16007 
          iprot.skip(ftype)
2536 chandransh 16008 
      else:
16009 
        iprot.skip(ftype)
16010 
      iprot.readFieldEnd()
16011 
    iprot.readStructEnd()
16012 
 
16013 
  def write(self, oprot):
16014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16016 
      return
16017 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 16018 
    if self.orderId is not None:
2536 chandransh 16019 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16020 
      oprot.writeI64(self.orderId)
16021 
      oprot.writeFieldEnd()
3431 rajveer 16022 
    if self.pickupNumber is not None:
2536 chandransh 16023 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
16024 
      oprot.writeString(self.pickupNumber)
16025 
      oprot.writeFieldEnd()
4602 rajveer 16026 
    if self.providerId is not None:
16027 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
16028 
      oprot.writeI64(self.providerId)
16029 
      oprot.writeFieldEnd()
2536 chandransh 16030 
    oprot.writeFieldStop()
16031 
    oprot.writeStructEnd()
16032 
 
3431 rajveer 16033 
  def validate(self):
16034 
    return
16035 
 
16036 
 
2536 chandransh 16037 
  def __repr__(self):
16038 
    L = ['%s=%r' % (key, value)
16039 
      for key, value in self.__dict__.iteritems()]
16040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16041 
 
16042 
  def __eq__(self, other):
16043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16044 
 
16045 
  def __ne__(self, other):
16046 
    return not (self == other)
16047 
 
16048 
class authorizePickup_result:
16049 
  """
16050 
  Attributes:
16051 
   - success
16052 
   - ex
16053 
  """
16054 
 
16055 
  thrift_spec = (
16056 
    (0, TType.BOOL, 'success', None, None, ), # 0
16057 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16058 
  )
16059 
 
16060 
  def __init__(self, success=None, ex=None,):
16061 
    self.success = success
16062 
    self.ex = ex
16063 
 
16064 
  def read(self, iprot):
16065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16067 
      return
16068 
    iprot.readStructBegin()
16069 
    while True:
16070 
      (fname, ftype, fid) = iprot.readFieldBegin()
16071 
      if ftype == TType.STOP:
16072 
        break
16073 
      if fid == 0:
16074 
        if ftype == TType.BOOL:
16075 
          self.success = iprot.readBool();
16076 
        else:
16077 
          iprot.skip(ftype)
16078 
      elif fid == 1:
16079 
        if ftype == TType.STRUCT:
16080 
          self.ex = TransactionServiceException()
16081 
          self.ex.read(iprot)
16082 
        else:
16083 
          iprot.skip(ftype)
16084 
      else:
16085 
        iprot.skip(ftype)
16086 
      iprot.readFieldEnd()
16087 
    iprot.readStructEnd()
16088 
 
16089 
  def write(self, oprot):
16090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16092 
      return
16093 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 16094 
    if self.success is not None:
2536 chandransh 16095 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16096 
      oprot.writeBool(self.success)
16097 
      oprot.writeFieldEnd()
3431 rajveer 16098 
    if self.ex is not None:
2536 chandransh 16099 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16100 
      self.ex.write(oprot)
16101 
      oprot.writeFieldEnd()
16102 
    oprot.writeFieldStop()
16103 
    oprot.writeStructEnd()
16104 
 
3431 rajveer 16105 
  def validate(self):
16106 
    return
16107 
 
16108 
 
2536 chandransh 16109 
  def __repr__(self):
16110 
    L = ['%s=%r' % (key, value)
16111 
      for key, value in self.__dict__.iteritems()]
16112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16113 
 
16114 
  def __eq__(self, other):
16115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16116 
 
16117 
  def __ne__(self, other):
16118 
    return not (self == other)
16119 
 
2764 chandransh 16120 
class markDoasAsPickedUp_args:
16121 
  """
16122 
  Attributes:
16123 
   - providerId
16124 
   - pickupDetails
16125 
  """
16126 
 
16127 
  thrift_spec = (
16128 
    None, # 0
16129 
    (1, TType.I64, 'providerId', None, None, ), # 1
16130 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16131 
  )
16132 
 
16133 
  def __init__(self, providerId=None, pickupDetails=None,):
16134 
    self.providerId = providerId
16135 
    self.pickupDetails = pickupDetails
16136 
 
16137 
  def read(self, iprot):
16138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16140 
      return
16141 
    iprot.readStructBegin()
16142 
    while True:
16143 
      (fname, ftype, fid) = iprot.readFieldBegin()
16144 
      if ftype == TType.STOP:
16145 
        break
16146 
      if fid == 1:
16147 
        if ftype == TType.I64:
16148 
          self.providerId = iprot.readI64();
16149 
        else:
16150 
          iprot.skip(ftype)
16151 
      elif fid == 2:
16152 
        if ftype == TType.MAP:
16153 
          self.pickupDetails = {}
5713 rajveer 16154 
          (_ktype365, _vtype366, _size364 ) = iprot.readMapBegin()
16155 
          for _i368 in xrange(_size364):
16156 
            _key369 = iprot.readString();
16157 
            _val370 = iprot.readString();
16158 
            self.pickupDetails[_key369] = _val370
2764 chandransh 16159 
          iprot.readMapEnd()
16160 
        else:
16161 
          iprot.skip(ftype)
16162 
      else:
16163 
        iprot.skip(ftype)
16164 
      iprot.readFieldEnd()
16165 
    iprot.readStructEnd()
16166 
 
16167 
  def write(self, oprot):
16168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16170 
      return
16171 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 16172 
    if self.providerId is not None:
2764 chandransh 16173 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16174 
      oprot.writeI64(self.providerId)
16175 
      oprot.writeFieldEnd()
3431 rajveer 16176 
    if self.pickupDetails is not None:
2764 chandransh 16177 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16178 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5713 rajveer 16179 
      for kiter371,viter372 in self.pickupDetails.items():
16180 
        oprot.writeString(kiter371)
16181 
        oprot.writeString(viter372)
2764 chandransh 16182 
      oprot.writeMapEnd()
16183 
      oprot.writeFieldEnd()
16184 
    oprot.writeFieldStop()
16185 
    oprot.writeStructEnd()
16186 
 
3431 rajveer 16187 
  def validate(self):
16188 
    return
16189 
 
16190 
 
2764 chandransh 16191 
  def __repr__(self):
16192 
    L = ['%s=%r' % (key, value)
16193 
      for key, value in self.__dict__.iteritems()]
16194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16195 
 
16196 
  def __eq__(self, other):
16197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16198 
 
16199 
  def __ne__(self, other):
16200 
    return not (self == other)
16201 
 
16202 
class markDoasAsPickedUp_result:
4910 phani.kuma 16203 
 
16204 
  thrift_spec = (
16205 
  )
16206 
 
16207 
  def read(self, iprot):
16208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16210 
      return
16211 
    iprot.readStructBegin()
16212 
    while True:
16213 
      (fname, ftype, fid) = iprot.readFieldBegin()
16214 
      if ftype == TType.STOP:
16215 
        break
16216 
      else:
16217 
        iprot.skip(ftype)
16218 
      iprot.readFieldEnd()
16219 
    iprot.readStructEnd()
16220 
 
16221 
  def write(self, oprot):
16222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16224 
      return
16225 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
16226 
    oprot.writeFieldStop()
16227 
    oprot.writeStructEnd()
16228 
 
16229 
  def validate(self):
16230 
    return
16231 
 
16232 
 
16233 
  def __repr__(self):
16234 
    L = ['%s=%r' % (key, value)
16235 
      for key, value in self.__dict__.iteritems()]
16236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16237 
 
16238 
  def __eq__(self, other):
16239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16240 
 
16241 
  def __ne__(self, other):
16242 
    return not (self == other)
16243 
 
16244 
class getDoasNotPickedUp_args:
2764 chandransh 16245 
  """
16246 
  Attributes:
4910 phani.kuma 16247 
   - providerId
16248 
  """
16249 
 
16250 
  thrift_spec = (
16251 
    None, # 0
16252 
    (1, TType.I64, 'providerId', None, None, ), # 1
16253 
  )
16254 
 
16255 
  def __init__(self, providerId=None,):
16256 
    self.providerId = providerId
16257 
 
16258 
  def read(self, iprot):
16259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16261 
      return
16262 
    iprot.readStructBegin()
16263 
    while True:
16264 
      (fname, ftype, fid) = iprot.readFieldBegin()
16265 
      if ftype == TType.STOP:
16266 
        break
16267 
      if fid == 1:
16268 
        if ftype == TType.I64:
16269 
          self.providerId = iprot.readI64();
16270 
        else:
16271 
          iprot.skip(ftype)
16272 
      else:
16273 
        iprot.skip(ftype)
16274 
      iprot.readFieldEnd()
16275 
    iprot.readStructEnd()
16276 
 
16277 
  def write(self, oprot):
16278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16280 
      return
16281 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
16282 
    if self.providerId is not None:
16283 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16284 
      oprot.writeI64(self.providerId)
16285 
      oprot.writeFieldEnd()
16286 
    oprot.writeFieldStop()
16287 
    oprot.writeStructEnd()
16288 
 
16289 
  def validate(self):
16290 
    return
16291 
 
16292 
 
16293 
  def __repr__(self):
16294 
    L = ['%s=%r' % (key, value)
16295 
      for key, value in self.__dict__.iteritems()]
16296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16297 
 
16298 
  def __eq__(self, other):
16299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16300 
 
16301 
  def __ne__(self, other):
16302 
    return not (self == other)
16303 
 
16304 
class getDoasNotPickedUp_result:
16305 
  """
16306 
  Attributes:
2764 chandransh 16307 
   - success
16308 
  """
16309 
 
16310 
  thrift_spec = (
16311 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16312 
  )
16313 
 
16314 
  def __init__(self, success=None,):
16315 
    self.success = success
16316 
 
16317 
  def read(self, iprot):
16318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16320 
      return
16321 
    iprot.readStructBegin()
16322 
    while True:
16323 
      (fname, ftype, fid) = iprot.readFieldBegin()
16324 
      if ftype == TType.STOP:
16325 
        break
16326 
      if fid == 0:
16327 
        if ftype == TType.LIST:
16328 
          self.success = []
5713 rajveer 16329 
          (_etype376, _size373) = iprot.readListBegin()
16330 
          for _i377 in xrange(_size373):
16331 
            _elem378 = Order()
16332 
            _elem378.read(iprot)
16333 
            self.success.append(_elem378)
2764 chandransh 16334 
          iprot.readListEnd()
16335 
        else:
16336 
          iprot.skip(ftype)
16337 
      else:
16338 
        iprot.skip(ftype)
16339 
      iprot.readFieldEnd()
16340 
    iprot.readStructEnd()
16341 
 
16342 
  def write(self, oprot):
16343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16345 
      return
4910 phani.kuma 16346 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 16347 
    if self.success is not None:
2764 chandransh 16348 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16349 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 16350 
      for iter379 in self.success:
16351 
        iter379.write(oprot)
2764 chandransh 16352 
      oprot.writeListEnd()
16353 
      oprot.writeFieldEnd()
16354 
    oprot.writeFieldStop()
16355 
    oprot.writeStructEnd()
16356 
 
3431 rajveer 16357 
  def validate(self):
16358 
    return
16359 
 
16360 
 
2764 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 
 
4741 phani.kuma 16372 
class markReturnOrdersAsPickedUp_args:
16373 
  """
16374 
  Attributes:
16375 
   - providerId
16376 
   - pickupDetails
16377 
  """
16378 
 
16379 
  thrift_spec = (
16380 
    None, # 0
16381 
    (1, TType.I64, 'providerId', None, None, ), # 1
16382 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16383 
  )
16384 
 
16385 
  def __init__(self, providerId=None, pickupDetails=None,):
16386 
    self.providerId = providerId
16387 
    self.pickupDetails = pickupDetails
16388 
 
16389 
  def read(self, iprot):
16390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16392 
      return
16393 
    iprot.readStructBegin()
16394 
    while True:
16395 
      (fname, ftype, fid) = iprot.readFieldBegin()
16396 
      if ftype == TType.STOP:
16397 
        break
16398 
      if fid == 1:
16399 
        if ftype == TType.I64:
16400 
          self.providerId = iprot.readI64();
16401 
        else:
16402 
          iprot.skip(ftype)
16403 
      elif fid == 2:
16404 
        if ftype == TType.MAP:
16405 
          self.pickupDetails = {}
5713 rajveer 16406 
          (_ktype381, _vtype382, _size380 ) = iprot.readMapBegin()
16407 
          for _i384 in xrange(_size380):
16408 
            _key385 = iprot.readString();
16409 
            _val386 = iprot.readString();
16410 
            self.pickupDetails[_key385] = _val386
4741 phani.kuma 16411 
          iprot.readMapEnd()
16412 
        else:
16413 
          iprot.skip(ftype)
16414 
      else:
16415 
        iprot.skip(ftype)
16416 
      iprot.readFieldEnd()
16417 
    iprot.readStructEnd()
16418 
 
16419 
  def write(self, oprot):
16420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16422 
      return
16423 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
16424 
    if self.providerId is not None:
16425 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16426 
      oprot.writeI64(self.providerId)
16427 
      oprot.writeFieldEnd()
16428 
    if self.pickupDetails is not None:
16429 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16430 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5713 rajveer 16431 
      for kiter387,viter388 in self.pickupDetails.items():
16432 
        oprot.writeString(kiter387)
16433 
        oprot.writeString(viter388)
4741 phani.kuma 16434 
      oprot.writeMapEnd()
16435 
      oprot.writeFieldEnd()
16436 
    oprot.writeFieldStop()
16437 
    oprot.writeStructEnd()
16438 
 
16439 
  def validate(self):
16440 
    return
16441 
 
16442 
 
16443 
  def __repr__(self):
16444 
    L = ['%s=%r' % (key, value)
16445 
      for key, value in self.__dict__.iteritems()]
16446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16447 
 
16448 
  def __eq__(self, other):
16449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16450 
 
16451 
  def __ne__(self, other):
16452 
    return not (self == other)
16453 
 
16454 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 16455 
 
16456 
  thrift_spec = (
16457 
  )
16458 
 
16459 
  def read(self, iprot):
16460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16462 
      return
16463 
    iprot.readStructBegin()
16464 
    while True:
16465 
      (fname, ftype, fid) = iprot.readFieldBegin()
16466 
      if ftype == TType.STOP:
16467 
        break
16468 
      else:
16469 
        iprot.skip(ftype)
16470 
      iprot.readFieldEnd()
16471 
    iprot.readStructEnd()
16472 
 
16473 
  def write(self, oprot):
16474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16476 
      return
16477 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
16478 
    oprot.writeFieldStop()
16479 
    oprot.writeStructEnd()
16480 
 
16481 
  def validate(self):
16482 
    return
16483 
 
16484 
 
16485 
  def __repr__(self):
16486 
    L = ['%s=%r' % (key, value)
16487 
      for key, value in self.__dict__.iteritems()]
16488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16489 
 
16490 
  def __eq__(self, other):
16491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16492 
 
16493 
  def __ne__(self, other):
16494 
    return not (self == other)
16495 
 
16496 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 16497 
  """
16498 
  Attributes:
4910 phani.kuma 16499 
   - providerId
16500 
  """
16501 
 
16502 
  thrift_spec = (
16503 
    None, # 0
16504 
    (1, TType.I64, 'providerId', None, None, ), # 1
16505 
  )
16506 
 
16507 
  def __init__(self, providerId=None,):
16508 
    self.providerId = providerId
16509 
 
16510 
  def read(self, iprot):
16511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16513 
      return
16514 
    iprot.readStructBegin()
16515 
    while True:
16516 
      (fname, ftype, fid) = iprot.readFieldBegin()
16517 
      if ftype == TType.STOP:
16518 
        break
16519 
      if fid == 1:
16520 
        if ftype == TType.I64:
16521 
          self.providerId = iprot.readI64();
16522 
        else:
16523 
          iprot.skip(ftype)
16524 
      else:
16525 
        iprot.skip(ftype)
16526 
      iprot.readFieldEnd()
16527 
    iprot.readStructEnd()
16528 
 
16529 
  def write(self, oprot):
16530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16532 
      return
16533 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
16534 
    if self.providerId is not None:
16535 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16536 
      oprot.writeI64(self.providerId)
16537 
      oprot.writeFieldEnd()
16538 
    oprot.writeFieldStop()
16539 
    oprot.writeStructEnd()
16540 
 
16541 
  def validate(self):
16542 
    return
16543 
 
16544 
 
16545 
  def __repr__(self):
16546 
    L = ['%s=%r' % (key, value)
16547 
      for key, value in self.__dict__.iteritems()]
16548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16549 
 
16550 
  def __eq__(self, other):
16551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16552 
 
16553 
  def __ne__(self, other):
16554 
    return not (self == other)
16555 
 
16556 
class getReturnOrdersNotPickedUp_result:
16557 
  """
16558 
  Attributes:
4741 phani.kuma 16559 
   - success
16560 
  """
16561 
 
16562 
  thrift_spec = (
16563 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16564 
  )
16565 
 
16566 
  def __init__(self, success=None,):
16567 
    self.success = success
16568 
 
16569 
  def read(self, iprot):
16570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16572 
      return
16573 
    iprot.readStructBegin()
16574 
    while True:
16575 
      (fname, ftype, fid) = iprot.readFieldBegin()
16576 
      if ftype == TType.STOP:
16577 
        break
16578 
      if fid == 0:
16579 
        if ftype == TType.LIST:
16580 
          self.success = []
5713 rajveer 16581 
          (_etype392, _size389) = iprot.readListBegin()
16582 
          for _i393 in xrange(_size389):
16583 
            _elem394 = Order()
16584 
            _elem394.read(iprot)
16585 
            self.success.append(_elem394)
4741 phani.kuma 16586 
          iprot.readListEnd()
16587 
        else:
16588 
          iprot.skip(ftype)
16589 
      else:
16590 
        iprot.skip(ftype)
16591 
      iprot.readFieldEnd()
16592 
    iprot.readStructEnd()
16593 
 
16594 
  def write(self, oprot):
16595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16597 
      return
4910 phani.kuma 16598 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 16599 
    if self.success is not None:
16600 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16601 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 16602 
      for iter395 in self.success:
16603 
        iter395.write(oprot)
4741 phani.kuma 16604 
      oprot.writeListEnd()
16605 
      oprot.writeFieldEnd()
16606 
    oprot.writeFieldStop()
16607 
    oprot.writeStructEnd()
16608 
 
16609 
  def validate(self):
16610 
    return
16611 
 
16612 
 
16613 
  def __repr__(self):
16614 
    L = ['%s=%r' % (key, value)
16615 
      for key, value in self.__dict__.iteritems()]
16616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16617 
 
16618 
  def __eq__(self, other):
16619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16620 
 
16621 
  def __ne__(self, other):
16622 
    return not (self == other)
16623 
 
2616 chandransh 16624 
class receiveReturn_args:
2591 chandransh 16625 
  """
16626 
  Attributes:
16627 
   - orderId
4479 rajveer 16628 
   - receiveCondition
2591 chandransh 16629 
  """
2536 chandransh 16630 
 
2591 chandransh 16631 
  thrift_spec = (
16632 
    None, # 0
16633 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 16634 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 16635 
  )
16636 
 
4479 rajveer 16637 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 16638 
    self.orderId = orderId
4479 rajveer 16639 
    self.receiveCondition = receiveCondition
2591 chandransh 16640 
 
16641 
  def read(self, iprot):
16642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16644 
      return
16645 
    iprot.readStructBegin()
16646 
    while True:
16647 
      (fname, ftype, fid) = iprot.readFieldBegin()
16648 
      if ftype == TType.STOP:
16649 
        break
16650 
      if fid == 1:
16651 
        if ftype == TType.I64:
16652 
          self.orderId = iprot.readI64();
16653 
        else:
16654 
          iprot.skip(ftype)
4479 rajveer 16655 
      elif fid == 2:
16656 
        if ftype == TType.I64:
16657 
          self.receiveCondition = iprot.readI64();
16658 
        else:
16659 
          iprot.skip(ftype)
2591 chandransh 16660 
      else:
16661 
        iprot.skip(ftype)
16662 
      iprot.readFieldEnd()
16663 
    iprot.readStructEnd()
16664 
 
16665 
  def write(self, oprot):
16666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16668 
      return
2616 chandransh 16669 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 16670 
    if self.orderId is not None:
2591 chandransh 16671 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16672 
      oprot.writeI64(self.orderId)
16673 
      oprot.writeFieldEnd()
4479 rajveer 16674 
    if self.receiveCondition is not None:
16675 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
16676 
      oprot.writeI64(self.receiveCondition)
16677 
      oprot.writeFieldEnd()
2591 chandransh 16678 
    oprot.writeFieldStop()
16679 
    oprot.writeStructEnd()
16680 
 
3431 rajveer 16681 
  def validate(self):
16682 
    return
16683 
 
16684 
 
2591 chandransh 16685 
  def __repr__(self):
16686 
    L = ['%s=%r' % (key, value)
16687 
      for key, value in self.__dict__.iteritems()]
16688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16689 
 
16690 
  def __eq__(self, other):
16691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16692 
 
16693 
  def __ne__(self, other):
16694 
    return not (self == other)
16695 
 
2616 chandransh 16696 
class receiveReturn_result:
2591 chandransh 16697 
  """
16698 
  Attributes:
16699 
   - success
16700 
   - ex
16701 
  """
16702 
 
16703 
  thrift_spec = (
16704 
    (0, TType.BOOL, 'success', None, None, ), # 0
16705 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16706 
  )
16707 
 
16708 
  def __init__(self, success=None, ex=None,):
16709 
    self.success = success
16710 
    self.ex = ex
16711 
 
16712 
  def read(self, iprot):
16713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16715 
      return
16716 
    iprot.readStructBegin()
16717 
    while True:
16718 
      (fname, ftype, fid) = iprot.readFieldBegin()
16719 
      if ftype == TType.STOP:
16720 
        break
16721 
      if fid == 0:
16722 
        if ftype == TType.BOOL:
16723 
          self.success = iprot.readBool();
16724 
        else:
16725 
          iprot.skip(ftype)
16726 
      elif fid == 1:
16727 
        if ftype == TType.STRUCT:
16728 
          self.ex = TransactionServiceException()
16729 
          self.ex.read(iprot)
16730 
        else:
16731 
          iprot.skip(ftype)
16732 
      else:
16733 
        iprot.skip(ftype)
16734 
      iprot.readFieldEnd()
16735 
    iprot.readStructEnd()
16736 
 
16737 
  def write(self, oprot):
16738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16740 
      return
2616 chandransh 16741 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 16742 
    if self.success is not None:
2591 chandransh 16743 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16744 
      oprot.writeBool(self.success)
16745 
      oprot.writeFieldEnd()
3431 rajveer 16746 
    if self.ex is not None:
2591 chandransh 16747 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16748 
      self.ex.write(oprot)
16749 
      oprot.writeFieldEnd()
16750 
    oprot.writeFieldStop()
16751 
    oprot.writeStructEnd()
16752 
 
3431 rajveer 16753 
  def validate(self):
16754 
    return
16755 
 
16756 
 
2591 chandransh 16757 
  def __repr__(self):
16758 
    L = ['%s=%r' % (key, value)
16759 
      for key, value in self.__dict__.iteritems()]
16760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16761 
 
16762 
  def __eq__(self, other):
16763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16764 
 
16765 
  def __ne__(self, other):
16766 
    return not (self == other)
16767 
 
16768 
class validateDoa_args:
16769 
  """
16770 
  Attributes:
16771 
   - orderId
16772 
   - isValid
16773 
  """
16774 
 
16775 
  thrift_spec = (
16776 
    None, # 0
16777 
    (1, TType.I64, 'orderId', None, None, ), # 1
16778 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
16779 
  )
16780 
 
16781 
  def __init__(self, orderId=None, isValid=None,):
16782 
    self.orderId = orderId
16783 
    self.isValid = isValid
16784 
 
16785 
  def read(self, iprot):
16786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16788 
      return
16789 
    iprot.readStructBegin()
16790 
    while True:
16791 
      (fname, ftype, fid) = iprot.readFieldBegin()
16792 
      if ftype == TType.STOP:
16793 
        break
16794 
      if fid == 1:
16795 
        if ftype == TType.I64:
16796 
          self.orderId = iprot.readI64();
16797 
        else:
16798 
          iprot.skip(ftype)
16799 
      elif fid == 2:
16800 
        if ftype == TType.BOOL:
16801 
          self.isValid = iprot.readBool();
16802 
        else:
16803 
          iprot.skip(ftype)
16804 
      else:
16805 
        iprot.skip(ftype)
16806 
      iprot.readFieldEnd()
16807 
    iprot.readStructEnd()
16808 
 
16809 
  def write(self, oprot):
16810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16812 
      return
16813 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 16814 
    if self.orderId is not None:
2591 chandransh 16815 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16816 
      oprot.writeI64(self.orderId)
16817 
      oprot.writeFieldEnd()
3431 rajveer 16818 
    if self.isValid is not None:
2591 chandransh 16819 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
16820 
      oprot.writeBool(self.isValid)
16821 
      oprot.writeFieldEnd()
16822 
    oprot.writeFieldStop()
16823 
    oprot.writeStructEnd()
16824 
 
3431 rajveer 16825 
  def validate(self):
16826 
    return
16827 
 
16828 
 
2591 chandransh 16829 
  def __repr__(self):
16830 
    L = ['%s=%r' % (key, value)
16831 
      for key, value in self.__dict__.iteritems()]
16832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16833 
 
16834 
  def __eq__(self, other):
16835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16836 
 
16837 
  def __ne__(self, other):
16838 
    return not (self == other)
16839 
 
16840 
class validateDoa_result:
16841 
  """
16842 
  Attributes:
16843 
   - success
16844 
   - ex
16845 
  """
16846 
 
16847 
  thrift_spec = (
16848 
    (0, TType.BOOL, 'success', None, None, ), # 0
16849 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16850 
  )
16851 
 
16852 
  def __init__(self, success=None, ex=None,):
16853 
    self.success = success
16854 
    self.ex = ex
16855 
 
16856 
  def read(self, iprot):
16857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16859 
      return
16860 
    iprot.readStructBegin()
16861 
    while True:
16862 
      (fname, ftype, fid) = iprot.readFieldBegin()
16863 
      if ftype == TType.STOP:
16864 
        break
16865 
      if fid == 0:
16866 
        if ftype == TType.BOOL:
16867 
          self.success = iprot.readBool();
16868 
        else:
16869 
          iprot.skip(ftype)
16870 
      elif fid == 1:
16871 
        if ftype == TType.STRUCT:
16872 
          self.ex = TransactionServiceException()
16873 
          self.ex.read(iprot)
16874 
        else:
16875 
          iprot.skip(ftype)
16876 
      else:
16877 
        iprot.skip(ftype)
16878 
      iprot.readFieldEnd()
16879 
    iprot.readStructEnd()
16880 
 
16881 
  def write(self, oprot):
16882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16884 
      return
16885 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 16886 
    if self.success is not None:
2591 chandransh 16887 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16888 
      oprot.writeBool(self.success)
16889 
      oprot.writeFieldEnd()
3431 rajveer 16890 
    if self.ex is not None:
2591 chandransh 16891 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16892 
      self.ex.write(oprot)
16893 
      oprot.writeFieldEnd()
16894 
    oprot.writeFieldStop()
16895 
    oprot.writeStructEnd()
16896 
 
3431 rajveer 16897 
  def validate(self):
16898 
    return
16899 
 
16900 
 
2591 chandransh 16901 
  def __repr__(self):
16902 
    L = ['%s=%r' % (key, value)
16903 
      for key, value in self.__dict__.iteritems()]
16904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16905 
 
16906 
  def __eq__(self, other):
16907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16908 
 
16909 
  def __ne__(self, other):
16910 
    return not (self == other)
16911 
 
4495 rajveer 16912 
class validateReturnProduct_args:
16913 
  """
16914 
  Attributes:
16915 
   - orderId
16916 
   - isUsable
16917 
  """
16918 
 
16919 
  thrift_spec = (
16920 
    None, # 0
16921 
    (1, TType.I64, 'orderId', None, None, ), # 1
16922 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
16923 
  )
16924 
 
16925 
  def __init__(self, orderId=None, isUsable=None,):
16926 
    self.orderId = orderId
16927 
    self.isUsable = isUsable
16928 
 
16929 
  def read(self, iprot):
16930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16932 
      return
16933 
    iprot.readStructBegin()
16934 
    while True:
16935 
      (fname, ftype, fid) = iprot.readFieldBegin()
16936 
      if ftype == TType.STOP:
16937 
        break
16938 
      if fid == 1:
16939 
        if ftype == TType.I64:
16940 
          self.orderId = iprot.readI64();
16941 
        else:
16942 
          iprot.skip(ftype)
16943 
      elif fid == 2:
16944 
        if ftype == TType.BOOL:
16945 
          self.isUsable = iprot.readBool();
16946 
        else:
16947 
          iprot.skip(ftype)
16948 
      else:
16949 
        iprot.skip(ftype)
16950 
      iprot.readFieldEnd()
16951 
    iprot.readStructEnd()
16952 
 
16953 
  def write(self, oprot):
16954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16956 
      return
16957 
    oprot.writeStructBegin('validateReturnProduct_args')
16958 
    if self.orderId is not None:
16959 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16960 
      oprot.writeI64(self.orderId)
16961 
      oprot.writeFieldEnd()
16962 
    if self.isUsable is not None:
16963 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
16964 
      oprot.writeBool(self.isUsable)
16965 
      oprot.writeFieldEnd()
16966 
    oprot.writeFieldStop()
16967 
    oprot.writeStructEnd()
16968 
 
16969 
  def validate(self):
16970 
    return
16971 
 
16972 
 
16973 
  def __repr__(self):
16974 
    L = ['%s=%r' % (key, value)
16975 
      for key, value in self.__dict__.iteritems()]
16976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16977 
 
16978 
  def __eq__(self, other):
16979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16980 
 
16981 
  def __ne__(self, other):
16982 
    return not (self == other)
16983 
 
16984 
class validateReturnProduct_result:
16985 
  """
16986 
  Attributes:
16987 
   - success
16988 
   - ex
16989 
  """
16990 
 
16991 
  thrift_spec = (
16992 
    (0, TType.BOOL, 'success', None, None, ), # 0
16993 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16994 
  )
16995 
 
16996 
  def __init__(self, success=None, ex=None,):
16997 
    self.success = success
16998 
    self.ex = ex
16999 
 
17000 
  def read(self, iprot):
17001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17003 
      return
17004 
    iprot.readStructBegin()
17005 
    while True:
17006 
      (fname, ftype, fid) = iprot.readFieldBegin()
17007 
      if ftype == TType.STOP:
17008 
        break
17009 
      if fid == 0:
17010 
        if ftype == TType.BOOL:
17011 
          self.success = iprot.readBool();
17012 
        else:
17013 
          iprot.skip(ftype)
17014 
      elif fid == 1:
17015 
        if ftype == TType.STRUCT:
17016 
          self.ex = TransactionServiceException()
17017 
          self.ex.read(iprot)
17018 
        else:
17019 
          iprot.skip(ftype)
17020 
      else:
17021 
        iprot.skip(ftype)
17022 
      iprot.readFieldEnd()
17023 
    iprot.readStructEnd()
17024 
 
17025 
  def write(self, oprot):
17026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17028 
      return
17029 
    oprot.writeStructBegin('validateReturnProduct_result')
17030 
    if self.success is not None:
17031 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17032 
      oprot.writeBool(self.success)
17033 
      oprot.writeFieldEnd()
17034 
    if self.ex is not None:
17035 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17036 
      self.ex.write(oprot)
17037 
      oprot.writeFieldEnd()
17038 
    oprot.writeFieldStop()
17039 
    oprot.writeStructEnd()
17040 
 
17041 
  def validate(self):
17042 
    return
17043 
 
17044 
 
17045 
  def __repr__(self):
17046 
    L = ['%s=%r' % (key, value)
17047 
      for key, value in self.__dict__.iteritems()]
17048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17049 
 
17050 
  def __eq__(self, other):
17051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17052 
 
17053 
  def __ne__(self, other):
17054 
    return not (self == other)
17055 
 
2616 chandransh 17056 
class reshipOrder_args:
17057 
  """
17058 
  Attributes:
17059 
   - orderId
17060 
  """
2591 chandransh 17061 
 
2616 chandransh 17062 
  thrift_spec = (
17063 
    None, # 0
17064 
    (1, TType.I64, 'orderId', None, None, ), # 1
17065 
  )
17066 
 
17067 
  def __init__(self, orderId=None,):
17068 
    self.orderId = orderId
17069 
 
17070 
  def read(self, iprot):
17071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17073 
      return
17074 
    iprot.readStructBegin()
17075 
    while True:
17076 
      (fname, ftype, fid) = iprot.readFieldBegin()
17077 
      if ftype == TType.STOP:
17078 
        break
17079 
      if fid == 1:
17080 
        if ftype == TType.I64:
17081 
          self.orderId = iprot.readI64();
17082 
        else:
17083 
          iprot.skip(ftype)
17084 
      else:
17085 
        iprot.skip(ftype)
17086 
      iprot.readFieldEnd()
17087 
    iprot.readStructEnd()
17088 
 
17089 
  def write(self, oprot):
17090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17092 
      return
17093 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 17094 
    if self.orderId is not None:
2616 chandransh 17095 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17096 
      oprot.writeI64(self.orderId)
17097 
      oprot.writeFieldEnd()
17098 
    oprot.writeFieldStop()
17099 
    oprot.writeStructEnd()
17100 
 
3431 rajveer 17101 
  def validate(self):
17102 
    return
17103 
 
17104 
 
2616 chandransh 17105 
  def __repr__(self):
17106 
    L = ['%s=%r' % (key, value)
17107 
      for key, value in self.__dict__.iteritems()]
17108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17109 
 
17110 
  def __eq__(self, other):
17111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17112 
 
17113 
  def __ne__(self, other):
17114 
    return not (self == other)
17115 
 
17116 
class reshipOrder_result:
17117 
  """
17118 
  Attributes:
17119 
   - success
17120 
   - ex
17121 
  """
17122 
 
17123 
  thrift_spec = (
17124 
    (0, TType.I64, 'success', None, None, ), # 0
17125 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17126 
  )
17127 
 
17128 
  def __init__(self, success=None, ex=None,):
17129 
    self.success = success
17130 
    self.ex = ex
17131 
 
17132 
  def read(self, iprot):
17133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17135 
      return
17136 
    iprot.readStructBegin()
17137 
    while True:
17138 
      (fname, ftype, fid) = iprot.readFieldBegin()
17139 
      if ftype == TType.STOP:
17140 
        break
17141 
      if fid == 0:
17142 
        if ftype == TType.I64:
17143 
          self.success = iprot.readI64();
17144 
        else:
17145 
          iprot.skip(ftype)
17146 
      elif fid == 1:
17147 
        if ftype == TType.STRUCT:
17148 
          self.ex = TransactionServiceException()
17149 
          self.ex.read(iprot)
17150 
        else:
17151 
          iprot.skip(ftype)
17152 
      else:
17153 
        iprot.skip(ftype)
17154 
      iprot.readFieldEnd()
17155 
    iprot.readStructEnd()
17156 
 
17157 
  def write(self, oprot):
17158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17160 
      return
17161 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 17162 
    if self.success is not None:
2616 chandransh 17163 
      oprot.writeFieldBegin('success', TType.I64, 0)
17164 
      oprot.writeI64(self.success)
17165 
      oprot.writeFieldEnd()
3431 rajveer 17166 
    if self.ex is not None:
2616 chandransh 17167 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17168 
      self.ex.write(oprot)
17169 
      oprot.writeFieldEnd()
17170 
    oprot.writeFieldStop()
17171 
    oprot.writeStructEnd()
17172 
 
3431 rajveer 17173 
  def validate(self):
17174 
    return
17175 
 
17176 
 
2616 chandransh 17177 
  def __repr__(self):
17178 
    L = ['%s=%r' % (key, value)
17179 
      for key, value in self.__dict__.iteritems()]
17180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17181 
 
17182 
  def __eq__(self, other):
17183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17184 
 
17185 
  def __ne__(self, other):
17186 
    return not (self == other)
17187 
 
17188 
class refundOrder_args:
17189 
  """
17190 
  Attributes:
17191 
   - orderId
3226 chandransh 17192 
   - refundedBy
17193 
   - reason
2616 chandransh 17194 
  """
17195 
 
17196 
  thrift_spec = (
17197 
    None, # 0
17198 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 17199 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
17200 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 17201 
  )
17202 
 
3226 chandransh 17203 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 17204 
    self.orderId = orderId
3226 chandransh 17205 
    self.refundedBy = refundedBy
17206 
    self.reason = reason
2616 chandransh 17207 
 
17208 
  def read(self, iprot):
17209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17211 
      return
17212 
    iprot.readStructBegin()
17213 
    while True:
17214 
      (fname, ftype, fid) = iprot.readFieldBegin()
17215 
      if ftype == TType.STOP:
17216 
        break
17217 
      if fid == 1:
17218 
        if ftype == TType.I64:
17219 
          self.orderId = iprot.readI64();
17220 
        else:
17221 
          iprot.skip(ftype)
3226 chandransh 17222 
      elif fid == 2:
17223 
        if ftype == TType.STRING:
17224 
          self.refundedBy = iprot.readString();
17225 
        else:
17226 
          iprot.skip(ftype)
17227 
      elif fid == 3:
17228 
        if ftype == TType.STRING:
17229 
          self.reason = iprot.readString();
17230 
        else:
17231 
          iprot.skip(ftype)
2616 chandransh 17232 
      else:
17233 
        iprot.skip(ftype)
17234 
      iprot.readFieldEnd()
17235 
    iprot.readStructEnd()
17236 
 
17237 
  def write(self, oprot):
17238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17240 
      return
17241 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 17242 
    if self.orderId is not None:
2616 chandransh 17243 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17244 
      oprot.writeI64(self.orderId)
17245 
      oprot.writeFieldEnd()
3431 rajveer 17246 
    if self.refundedBy is not None:
3226 chandransh 17247 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
17248 
      oprot.writeString(self.refundedBy)
17249 
      oprot.writeFieldEnd()
3431 rajveer 17250 
    if self.reason is not None:
3226 chandransh 17251 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
17252 
      oprot.writeString(self.reason)
17253 
      oprot.writeFieldEnd()
2616 chandransh 17254 
    oprot.writeFieldStop()
17255 
    oprot.writeStructEnd()
17256 
 
3431 rajveer 17257 
  def validate(self):
17258 
    return
17259 
 
17260 
 
2616 chandransh 17261 
  def __repr__(self):
17262 
    L = ['%s=%r' % (key, value)
17263 
      for key, value in self.__dict__.iteritems()]
17264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17265 
 
17266 
  def __eq__(self, other):
17267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17268 
 
17269 
  def __ne__(self, other):
17270 
    return not (self == other)
17271 
 
17272 
class refundOrder_result:
17273 
  """
17274 
  Attributes:
17275 
   - success
17276 
   - ex
17277 
  """
17278 
 
17279 
  thrift_spec = (
17280 
    (0, TType.BOOL, 'success', None, None, ), # 0
17281 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17282 
  )
17283 
 
17284 
  def __init__(self, success=None, ex=None,):
17285 
    self.success = success
17286 
    self.ex = ex
17287 
 
17288 
  def read(self, iprot):
17289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17291 
      return
17292 
    iprot.readStructBegin()
17293 
    while True:
17294 
      (fname, ftype, fid) = iprot.readFieldBegin()
17295 
      if ftype == TType.STOP:
17296 
        break
17297 
      if fid == 0:
17298 
        if ftype == TType.BOOL:
17299 
          self.success = iprot.readBool();
17300 
        else:
17301 
          iprot.skip(ftype)
17302 
      elif fid == 1:
17303 
        if ftype == TType.STRUCT:
17304 
          self.ex = TransactionServiceException()
17305 
          self.ex.read(iprot)
17306 
        else:
17307 
          iprot.skip(ftype)
17308 
      else:
17309 
        iprot.skip(ftype)
17310 
      iprot.readFieldEnd()
17311 
    iprot.readStructEnd()
17312 
 
17313 
  def write(self, oprot):
17314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17316 
      return
17317 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 17318 
    if self.success is not None:
2616 chandransh 17319 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17320 
      oprot.writeBool(self.success)
17321 
      oprot.writeFieldEnd()
3431 rajveer 17322 
    if self.ex is not None:
2616 chandransh 17323 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17324 
      self.ex.write(oprot)
17325 
      oprot.writeFieldEnd()
17326 
    oprot.writeFieldStop()
17327 
    oprot.writeStructEnd()
17328 
 
3431 rajveer 17329 
  def validate(self):
17330 
    return
17331 
 
17332 
 
2616 chandransh 17333 
  def __repr__(self):
17334 
    L = ['%s=%r' % (key, value)
17335 
      for key, value in self.__dict__.iteritems()]
17336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17337 
 
17338 
  def __eq__(self, other):
17339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17340 
 
17341 
  def __ne__(self, other):
17342 
    return not (self == other)
17343 
 
2690 chandransh 17344 
class getReturnOrders_args:
17345 
  """
17346 
  Attributes:
17347 
   - warehouseId
17348 
   - fromDate
17349 
   - toDate
17350 
  """
2616 chandransh 17351 
 
2690 chandransh 17352 
  thrift_spec = (
17353 
    None, # 0
17354 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
17355 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17356 
    (3, TType.I64, 'toDate', None, None, ), # 3
17357 
  )
17358 
 
17359 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
17360 
    self.warehouseId = warehouseId
17361 
    self.fromDate = fromDate
17362 
    self.toDate = toDate
17363 
 
17364 
  def read(self, iprot):
17365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17367 
      return
17368 
    iprot.readStructBegin()
17369 
    while True:
17370 
      (fname, ftype, fid) = iprot.readFieldBegin()
17371 
      if ftype == TType.STOP:
17372 
        break
17373 
      if fid == 1:
17374 
        if ftype == TType.I64:
17375 
          self.warehouseId = iprot.readI64();
17376 
        else:
17377 
          iprot.skip(ftype)
17378 
      elif fid == 2:
17379 
        if ftype == TType.I64:
17380 
          self.fromDate = iprot.readI64();
17381 
        else:
17382 
          iprot.skip(ftype)
17383 
      elif fid == 3:
17384 
        if ftype == TType.I64:
17385 
          self.toDate = iprot.readI64();
17386 
        else:
17387 
          iprot.skip(ftype)
17388 
      else:
17389 
        iprot.skip(ftype)
17390 
      iprot.readFieldEnd()
17391 
    iprot.readStructEnd()
17392 
 
17393 
  def write(self, oprot):
17394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17396 
      return
17397 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 17398 
    if self.warehouseId is not None:
2690 chandransh 17399 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
17400 
      oprot.writeI64(self.warehouseId)
17401 
      oprot.writeFieldEnd()
3431 rajveer 17402 
    if self.fromDate is not None:
2690 chandransh 17403 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17404 
      oprot.writeI64(self.fromDate)
17405 
      oprot.writeFieldEnd()
3431 rajveer 17406 
    if self.toDate is not None:
2690 chandransh 17407 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17408 
      oprot.writeI64(self.toDate)
17409 
      oprot.writeFieldEnd()
17410 
    oprot.writeFieldStop()
17411 
    oprot.writeStructEnd()
17412 
 
3431 rajveer 17413 
  def validate(self):
17414 
    return
17415 
 
17416 
 
2690 chandransh 17417 
  def __repr__(self):
17418 
    L = ['%s=%r' % (key, value)
17419 
      for key, value in self.__dict__.iteritems()]
17420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17421 
 
17422 
  def __eq__(self, other):
17423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17424 
 
17425 
  def __ne__(self, other):
17426 
    return not (self == other)
17427 
 
17428 
class getReturnOrders_result:
17429 
  """
17430 
  Attributes:
17431 
   - success
17432 
  """
17433 
 
17434 
  thrift_spec = (
17435 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
17436 
  )
17437 
 
17438 
  def __init__(self, success=None,):
17439 
    self.success = success
17440 
 
17441 
  def read(self, iprot):
17442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17444 
      return
17445 
    iprot.readStructBegin()
17446 
    while True:
17447 
      (fname, ftype, fid) = iprot.readFieldBegin()
17448 
      if ftype == TType.STOP:
17449 
        break
17450 
      if fid == 0:
17451 
        if ftype == TType.LIST:
17452 
          self.success = []
5713 rajveer 17453 
          (_etype399, _size396) = iprot.readListBegin()
17454 
          for _i400 in xrange(_size396):
17455 
            _elem401 = ReturnOrder()
17456 
            _elem401.read(iprot)
17457 
            self.success.append(_elem401)
2690 chandransh 17458 
          iprot.readListEnd()
17459 
        else:
17460 
          iprot.skip(ftype)
17461 
      else:
17462 
        iprot.skip(ftype)
17463 
      iprot.readFieldEnd()
17464 
    iprot.readStructEnd()
17465 
 
17466 
  def write(self, oprot):
17467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17469 
      return
17470 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 17471 
    if self.success is not None:
2690 chandransh 17472 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17473 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 17474 
      for iter402 in self.success:
17475 
        iter402.write(oprot)
2690 chandransh 17476 
      oprot.writeListEnd()
17477 
      oprot.writeFieldEnd()
17478 
    oprot.writeFieldStop()
17479 
    oprot.writeStructEnd()
17480 
 
3431 rajveer 17481 
  def validate(self):
17482 
    return
17483 
 
17484 
 
2690 chandransh 17485 
  def __repr__(self):
17486 
    L = ['%s=%r' % (key, value)
17487 
      for key, value in self.__dict__.iteritems()]
17488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17489 
 
17490 
  def __eq__(self, other):
17491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17492 
 
17493 
  def __ne__(self, other):
17494 
    return not (self == other)
17495 
 
5481 phani.kuma 17496 
class getAllReturnOrders_args:
17497 
  """
17498 
  Attributes:
17499 
   - onlyNotProcessed
17500 
   - fromDate
17501 
   - toDate
17502 
  """
17503 
 
17504 
  thrift_spec = (
17505 
    None, # 0
17506 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
17507 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17508 
    (3, TType.I64, 'toDate', None, None, ), # 3
17509 
  )
17510 
 
17511 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
17512 
    self.onlyNotProcessed = onlyNotProcessed
17513 
    self.fromDate = fromDate
17514 
    self.toDate = toDate
17515 
 
17516 
  def read(self, iprot):
17517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17519 
      return
17520 
    iprot.readStructBegin()
17521 
    while True:
17522 
      (fname, ftype, fid) = iprot.readFieldBegin()
17523 
      if ftype == TType.STOP:
17524 
        break
17525 
      if fid == 1:
17526 
        if ftype == TType.BOOL:
17527 
          self.onlyNotProcessed = iprot.readBool();
17528 
        else:
17529 
          iprot.skip(ftype)
17530 
      elif fid == 2:
17531 
        if ftype == TType.I64:
17532 
          self.fromDate = iprot.readI64();
17533 
        else:
17534 
          iprot.skip(ftype)
17535 
      elif fid == 3:
17536 
        if ftype == TType.I64:
17537 
          self.toDate = iprot.readI64();
17538 
        else:
17539 
          iprot.skip(ftype)
17540 
      else:
17541 
        iprot.skip(ftype)
17542 
      iprot.readFieldEnd()
17543 
    iprot.readStructEnd()
17544 
 
17545 
  def write(self, oprot):
17546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17548 
      return
17549 
    oprot.writeStructBegin('getAllReturnOrders_args')
17550 
    if self.onlyNotProcessed is not None:
17551 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
17552 
      oprot.writeBool(self.onlyNotProcessed)
17553 
      oprot.writeFieldEnd()
17554 
    if self.fromDate is not None:
17555 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17556 
      oprot.writeI64(self.fromDate)
17557 
      oprot.writeFieldEnd()
17558 
    if self.toDate is not None:
17559 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17560 
      oprot.writeI64(self.toDate)
17561 
      oprot.writeFieldEnd()
17562 
    oprot.writeFieldStop()
17563 
    oprot.writeStructEnd()
17564 
 
17565 
  def validate(self):
17566 
    return
17567 
 
17568 
 
17569 
  def __repr__(self):
17570 
    L = ['%s=%r' % (key, value)
17571 
      for key, value in self.__dict__.iteritems()]
17572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17573 
 
17574 
  def __eq__(self, other):
17575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17576 
 
17577 
  def __ne__(self, other):
17578 
    return not (self == other)
17579 
 
17580 
class getAllReturnOrders_result:
17581 
  """
17582 
  Attributes:
17583 
   - success
17584 
  """
17585 
 
17586 
  thrift_spec = (
17587 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
17588 
  )
17589 
 
17590 
  def __init__(self, success=None,):
17591 
    self.success = success
17592 
 
17593 
  def read(self, iprot):
17594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17596 
      return
17597 
    iprot.readStructBegin()
17598 
    while True:
17599 
      (fname, ftype, fid) = iprot.readFieldBegin()
17600 
      if ftype == TType.STOP:
17601 
        break
17602 
      if fid == 0:
17603 
        if ftype == TType.LIST:
17604 
          self.success = []
5713 rajveer 17605 
          (_etype406, _size403) = iprot.readListBegin()
17606 
          for _i407 in xrange(_size403):
17607 
            _elem408 = ReturnOrder()
17608 
            _elem408.read(iprot)
17609 
            self.success.append(_elem408)
5481 phani.kuma 17610 
          iprot.readListEnd()
17611 
        else:
17612 
          iprot.skip(ftype)
17613 
      else:
17614 
        iprot.skip(ftype)
17615 
      iprot.readFieldEnd()
17616 
    iprot.readStructEnd()
17617 
 
17618 
  def write(self, oprot):
17619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17621 
      return
17622 
    oprot.writeStructBegin('getAllReturnOrders_result')
17623 
    if self.success is not None:
17624 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17625 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 17626 
      for iter409 in self.success:
17627 
        iter409.write(oprot)
5481 phani.kuma 17628 
      oprot.writeListEnd()
17629 
      oprot.writeFieldEnd()
17630 
    oprot.writeFieldStop()
17631 
    oprot.writeStructEnd()
17632 
 
17633 
  def validate(self):
17634 
    return
17635 
 
17636 
 
17637 
  def __repr__(self):
17638 
    L = ['%s=%r' % (key, value)
17639 
      for key, value in self.__dict__.iteritems()]
17640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17641 
 
17642 
  def __eq__(self, other):
17643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17644 
 
17645 
  def __ne__(self, other):
17646 
    return not (self == other)
17647 
 
2700 chandransh 17648 
class getReturnOrder_args:
17649 
  """
17650 
  Attributes:
17651 
   - id
17652 
  """
17653 
 
17654 
  thrift_spec = (
17655 
    None, # 0
17656 
    (1, TType.I64, 'id', None, None, ), # 1
17657 
  )
17658 
 
17659 
  def __init__(self, id=None,):
17660 
    self.id = id
17661 
 
17662 
  def read(self, iprot):
17663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17665 
      return
17666 
    iprot.readStructBegin()
17667 
    while True:
17668 
      (fname, ftype, fid) = iprot.readFieldBegin()
17669 
      if ftype == TType.STOP:
17670 
        break
17671 
      if fid == 1:
17672 
        if ftype == TType.I64:
17673 
          self.id = iprot.readI64();
17674 
        else:
17675 
          iprot.skip(ftype)
17676 
      else:
17677 
        iprot.skip(ftype)
17678 
      iprot.readFieldEnd()
17679 
    iprot.readStructEnd()
17680 
 
17681 
  def write(self, oprot):
17682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17684 
      return
17685 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 17686 
    if self.id is not None:
2700 chandransh 17687 
      oprot.writeFieldBegin('id', TType.I64, 1)
17688 
      oprot.writeI64(self.id)
17689 
      oprot.writeFieldEnd()
17690 
    oprot.writeFieldStop()
17691 
    oprot.writeStructEnd()
17692 
 
3431 rajveer 17693 
  def validate(self):
17694 
    return
17695 
 
17696 
 
2700 chandransh 17697 
  def __repr__(self):
17698 
    L = ['%s=%r' % (key, value)
17699 
      for key, value in self.__dict__.iteritems()]
17700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17701 
 
17702 
  def __eq__(self, other):
17703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17704 
 
17705 
  def __ne__(self, other):
17706 
    return not (self == other)
17707 
 
17708 
class getReturnOrder_result:
17709 
  """
17710 
  Attributes:
17711 
   - success
17712 
   - ex
17713 
  """
17714 
 
17715 
  thrift_spec = (
17716 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
17717 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17718 
  )
17719 
 
17720 
  def __init__(self, success=None, ex=None,):
17721 
    self.success = success
17722 
    self.ex = ex
17723 
 
17724 
  def read(self, iprot):
17725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17727 
      return
17728 
    iprot.readStructBegin()
17729 
    while True:
17730 
      (fname, ftype, fid) = iprot.readFieldBegin()
17731 
      if ftype == TType.STOP:
17732 
        break
17733 
      if fid == 0:
17734 
        if ftype == TType.STRUCT:
17735 
          self.success = ReturnOrder()
17736 
          self.success.read(iprot)
17737 
        else:
17738 
          iprot.skip(ftype)
17739 
      elif fid == 1:
17740 
        if ftype == TType.STRUCT:
17741 
          self.ex = TransactionServiceException()
17742 
          self.ex.read(iprot)
17743 
        else:
17744 
          iprot.skip(ftype)
17745 
      else:
17746 
        iprot.skip(ftype)
17747 
      iprot.readFieldEnd()
17748 
    iprot.readStructEnd()
17749 
 
17750 
  def write(self, oprot):
17751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17753 
      return
17754 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 17755 
    if self.success is not None:
2700 chandransh 17756 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17757 
      self.success.write(oprot)
17758 
      oprot.writeFieldEnd()
3431 rajveer 17759 
    if self.ex is not None:
2700 chandransh 17760 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17761 
      self.ex.write(oprot)
17762 
      oprot.writeFieldEnd()
17763 
    oprot.writeFieldStop()
17764 
    oprot.writeStructEnd()
17765 
 
3431 rajveer 17766 
  def validate(self):
17767 
    return
17768 
 
17769 
 
2700 chandransh 17770 
  def __repr__(self):
17771 
    L = ['%s=%r' % (key, value)
17772 
      for key, value in self.__dict__.iteritems()]
17773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17774 
 
17775 
  def __eq__(self, other):
17776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17777 
 
17778 
  def __ne__(self, other):
17779 
    return not (self == other)
17780 
 
2690 chandransh 17781 
class processReturn_args:
17782 
  """
17783 
  Attributes:
17784 
   - returnOrderId
17785 
  """
17786 
 
17787 
  thrift_spec = (
17788 
    None, # 0
17789 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
17790 
  )
17791 
 
17792 
  def __init__(self, returnOrderId=None,):
17793 
    self.returnOrderId = returnOrderId
17794 
 
17795 
  def read(self, iprot):
17796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17798 
      return
17799 
    iprot.readStructBegin()
17800 
    while True:
17801 
      (fname, ftype, fid) = iprot.readFieldBegin()
17802 
      if ftype == TType.STOP:
17803 
        break
17804 
      if fid == 1:
17805 
        if ftype == TType.I64:
17806 
          self.returnOrderId = iprot.readI64();
17807 
        else:
17808 
          iprot.skip(ftype)
17809 
      else:
17810 
        iprot.skip(ftype)
17811 
      iprot.readFieldEnd()
17812 
    iprot.readStructEnd()
17813 
 
17814 
  def write(self, oprot):
17815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17817 
      return
17818 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 17819 
    if self.returnOrderId is not None:
2690 chandransh 17820 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
17821 
      oprot.writeI64(self.returnOrderId)
17822 
      oprot.writeFieldEnd()
17823 
    oprot.writeFieldStop()
17824 
    oprot.writeStructEnd()
17825 
 
3431 rajveer 17826 
  def validate(self):
17827 
    return
17828 
 
17829 
 
2690 chandransh 17830 
  def __repr__(self):
17831 
    L = ['%s=%r' % (key, value)
17832 
      for key, value in self.__dict__.iteritems()]
17833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17834 
 
17835 
  def __eq__(self, other):
17836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17837 
 
17838 
  def __ne__(self, other):
17839 
    return not (self == other)
17840 
 
17841 
class processReturn_result:
17842 
  """
17843 
  Attributes:
17844 
   - ex
17845 
  """
17846 
 
17847 
  thrift_spec = (
17848 
    None, # 0
17849 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17850 
  )
17851 
 
17852 
  def __init__(self, ex=None,):
17853 
    self.ex = ex
17854 
 
17855 
  def read(self, iprot):
17856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17858 
      return
17859 
    iprot.readStructBegin()
17860 
    while True:
17861 
      (fname, ftype, fid) = iprot.readFieldBegin()
17862 
      if ftype == TType.STOP:
17863 
        break
17864 
      if fid == 1:
17865 
        if ftype == TType.STRUCT:
17866 
          self.ex = TransactionServiceException()
17867 
          self.ex.read(iprot)
17868 
        else:
17869 
          iprot.skip(ftype)
17870 
      else:
17871 
        iprot.skip(ftype)
17872 
      iprot.readFieldEnd()
17873 
    iprot.readStructEnd()
17874 
 
17875 
  def write(self, oprot):
17876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17878 
      return
17879 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 17880 
    if self.ex is not None:
2690 chandransh 17881 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17882 
      self.ex.write(oprot)
17883 
      oprot.writeFieldEnd()
17884 
    oprot.writeFieldStop()
17885 
    oprot.writeStructEnd()
17886 
 
3431 rajveer 17887 
  def validate(self):
17888 
    return
17889 
 
17890 
 
2690 chandransh 17891 
  def __repr__(self):
17892 
    L = ['%s=%r' % (key, value)
17893 
      for key, value in self.__dict__.iteritems()]
17894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17895 
 
17896 
  def __eq__(self, other):
17897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17898 
 
17899 
  def __ne__(self, other):
17900 
    return not (self == other)
17901 
 
3451 chandransh 17902 
class updateWeight_args:
17903 
  """
17904 
  Attributes:
17905 
   - orderId
17906 
   - weight
17907 
  """
17908 
 
17909 
  thrift_spec = (
17910 
    None, # 0
17911 
    (1, TType.I64, 'orderId', None, None, ), # 1
17912 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
17913 
  )
17914 
 
17915 
  def __init__(self, orderId=None, weight=None,):
17916 
    self.orderId = orderId
17917 
    self.weight = weight
17918 
 
17919 
  def read(self, iprot):
17920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17922 
      return
17923 
    iprot.readStructBegin()
17924 
    while True:
17925 
      (fname, ftype, fid) = iprot.readFieldBegin()
17926 
      if ftype == TType.STOP:
17927 
        break
17928 
      if fid == 1:
17929 
        if ftype == TType.I64:
17930 
          self.orderId = iprot.readI64();
17931 
        else:
17932 
          iprot.skip(ftype)
17933 
      elif fid == 2:
17934 
        if ftype == TType.DOUBLE:
17935 
          self.weight = iprot.readDouble();
17936 
        else:
17937 
          iprot.skip(ftype)
17938 
      else:
17939 
        iprot.skip(ftype)
17940 
      iprot.readFieldEnd()
17941 
    iprot.readStructEnd()
17942 
 
17943 
  def write(self, oprot):
17944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17946 
      return
17947 
    oprot.writeStructBegin('updateWeight_args')
17948 
    if self.orderId is not None:
17949 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17950 
      oprot.writeI64(self.orderId)
17951 
      oprot.writeFieldEnd()
17952 
    if self.weight is not None:
17953 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
17954 
      oprot.writeDouble(self.weight)
17955 
      oprot.writeFieldEnd()
17956 
    oprot.writeFieldStop()
17957 
    oprot.writeStructEnd()
17958 
 
17959 
  def validate(self):
17960 
    return
17961 
 
17962 
 
17963 
  def __repr__(self):
17964 
    L = ['%s=%r' % (key, value)
17965 
      for key, value in self.__dict__.iteritems()]
17966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17967 
 
17968 
  def __eq__(self, other):
17969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17970 
 
17971 
  def __ne__(self, other):
17972 
    return not (self == other)
17973 
 
17974 
class updateWeight_result:
17975 
  """
17976 
  Attributes:
17977 
   - success
17978 
   - ex
17979 
  """
17980 
 
17981 
  thrift_spec = (
17982 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17983 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17984 
  )
17985 
 
17986 
  def __init__(self, success=None, ex=None,):
17987 
    self.success = success
17988 
    self.ex = ex
17989 
 
17990 
  def read(self, iprot):
17991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17993 
      return
17994 
    iprot.readStructBegin()
17995 
    while True:
17996 
      (fname, ftype, fid) = iprot.readFieldBegin()
17997 
      if ftype == TType.STOP:
17998 
        break
17999 
      if fid == 0:
18000 
        if ftype == TType.STRUCT:
18001 
          self.success = Order()
18002 
          self.success.read(iprot)
18003 
        else:
18004 
          iprot.skip(ftype)
18005 
      elif fid == 1:
18006 
        if ftype == TType.STRUCT:
18007 
          self.ex = TransactionServiceException()
18008 
          self.ex.read(iprot)
18009 
        else:
18010 
          iprot.skip(ftype)
18011 
      else:
18012 
        iprot.skip(ftype)
18013 
      iprot.readFieldEnd()
18014 
    iprot.readStructEnd()
18015 
 
18016 
  def write(self, oprot):
18017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18019 
      return
18020 
    oprot.writeStructBegin('updateWeight_result')
18021 
    if self.success is not None:
18022 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18023 
      self.success.write(oprot)
18024 
      oprot.writeFieldEnd()
18025 
    if self.ex is not None:
18026 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18027 
      self.ex.write(oprot)
18028 
      oprot.writeFieldEnd()
18029 
    oprot.writeFieldStop()
18030 
    oprot.writeStructEnd()
18031 
 
18032 
  def validate(self):
18033 
    return
18034 
 
18035 
 
18036 
  def __repr__(self):
18037 
    L = ['%s=%r' % (key, value)
18038 
      for key, value in self.__dict__.iteritems()]
18039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18040 
 
18041 
  def __eq__(self, other):
18042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18043 
 
18044 
  def __ne__(self, other):
18045 
    return not (self == other)
3469 chandransh 18046 
 
18047 
class changeItem_args:
18048 
  """
18049 
  Attributes:
18050 
   - orderId
18051 
   - itemId
18052 
  """
18053 
 
18054 
  thrift_spec = (
18055 
    None, # 0
18056 
    (1, TType.I64, 'orderId', None, None, ), # 1
18057 
    (2, TType.I64, 'itemId', None, None, ), # 2
18058 
  )
18059 
 
18060 
  def __init__(self, orderId=None, itemId=None,):
18061 
    self.orderId = orderId
18062 
    self.itemId = itemId
18063 
 
18064 
  def read(self, iprot):
18065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18067 
      return
18068 
    iprot.readStructBegin()
18069 
    while True:
18070 
      (fname, ftype, fid) = iprot.readFieldBegin()
18071 
      if ftype == TType.STOP:
18072 
        break
18073 
      if fid == 1:
18074 
        if ftype == TType.I64:
18075 
          self.orderId = iprot.readI64();
18076 
        else:
18077 
          iprot.skip(ftype)
18078 
      elif fid == 2:
18079 
        if ftype == TType.I64:
18080 
          self.itemId = iprot.readI64();
18081 
        else:
18082 
          iprot.skip(ftype)
18083 
      else:
18084 
        iprot.skip(ftype)
18085 
      iprot.readFieldEnd()
18086 
    iprot.readStructEnd()
18087 
 
18088 
  def write(self, oprot):
18089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18091 
      return
18092 
    oprot.writeStructBegin('changeItem_args')
18093 
    if self.orderId is not None:
18094 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18095 
      oprot.writeI64(self.orderId)
18096 
      oprot.writeFieldEnd()
18097 
    if self.itemId is not None:
18098 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18099 
      oprot.writeI64(self.itemId)
18100 
      oprot.writeFieldEnd()
18101 
    oprot.writeFieldStop()
18102 
    oprot.writeStructEnd()
18103 
 
18104 
  def validate(self):
18105 
    return
18106 
 
18107 
 
18108 
  def __repr__(self):
18109 
    L = ['%s=%r' % (key, value)
18110 
      for key, value in self.__dict__.iteritems()]
18111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18112 
 
18113 
  def __eq__(self, other):
18114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18115 
 
18116 
  def __ne__(self, other):
18117 
    return not (self == other)
18118 
 
18119 
class changeItem_result:
18120 
  """
18121 
  Attributes:
18122 
   - success
18123 
   - ex
18124 
  """
18125 
 
18126 
  thrift_spec = (
18127 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18128 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18129 
  )
18130 
 
18131 
  def __init__(self, success=None, ex=None,):
18132 
    self.success = success
18133 
    self.ex = ex
18134 
 
18135 
  def read(self, iprot):
18136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18138 
      return
18139 
    iprot.readStructBegin()
18140 
    while True:
18141 
      (fname, ftype, fid) = iprot.readFieldBegin()
18142 
      if ftype == TType.STOP:
18143 
        break
18144 
      if fid == 0:
18145 
        if ftype == TType.STRUCT:
18146 
          self.success = Order()
18147 
          self.success.read(iprot)
18148 
        else:
18149 
          iprot.skip(ftype)
18150 
      elif fid == 1:
18151 
        if ftype == TType.STRUCT:
18152 
          self.ex = TransactionServiceException()
18153 
          self.ex.read(iprot)
18154 
        else:
18155 
          iprot.skip(ftype)
18156 
      else:
18157 
        iprot.skip(ftype)
18158 
      iprot.readFieldEnd()
18159 
    iprot.readStructEnd()
18160 
 
18161 
  def write(self, oprot):
18162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18164 
      return
18165 
    oprot.writeStructBegin('changeItem_result')
18166 
    if self.success is not None:
18167 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18168 
      self.success.write(oprot)
18169 
      oprot.writeFieldEnd()
18170 
    if self.ex is not None:
18171 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18172 
      self.ex.write(oprot)
18173 
      oprot.writeFieldEnd()
18174 
    oprot.writeFieldStop()
18175 
    oprot.writeStructEnd()
18176 
 
18177 
  def validate(self):
18178 
    return
18179 
 
18180 
 
18181 
  def __repr__(self):
18182 
    L = ['%s=%r' % (key, value)
18183 
      for key, value in self.__dict__.iteritems()]
18184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18185 
 
18186 
  def __eq__(self, other):
18187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18188 
 
18189 
  def __ne__(self, other):
18190 
    return not (self == other)
18191 
 
18192 
class shiftToWarehouse_args:
18193 
  """
18194 
  Attributes:
18195 
   - orderId
18196 
   - warehouseId
18197 
  """
18198 
 
18199 
  thrift_spec = (
18200 
    None, # 0
18201 
    (1, TType.I64, 'orderId', None, None, ), # 1
18202 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
18203 
  )
18204 
 
18205 
  def __init__(self, orderId=None, warehouseId=None,):
18206 
    self.orderId = orderId
18207 
    self.warehouseId = warehouseId
18208 
 
18209 
  def read(self, iprot):
18210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18212 
      return
18213 
    iprot.readStructBegin()
18214 
    while True:
18215 
      (fname, ftype, fid) = iprot.readFieldBegin()
18216 
      if ftype == TType.STOP:
18217 
        break
18218 
      if fid == 1:
18219 
        if ftype == TType.I64:
18220 
          self.orderId = iprot.readI64();
18221 
        else:
18222 
          iprot.skip(ftype)
18223 
      elif fid == 2:
18224 
        if ftype == TType.I64:
18225 
          self.warehouseId = iprot.readI64();
18226 
        else:
18227 
          iprot.skip(ftype)
18228 
      else:
18229 
        iprot.skip(ftype)
18230 
      iprot.readFieldEnd()
18231 
    iprot.readStructEnd()
18232 
 
18233 
  def write(self, oprot):
18234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18236 
      return
18237 
    oprot.writeStructBegin('shiftToWarehouse_args')
18238 
    if self.orderId is not None:
18239 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18240 
      oprot.writeI64(self.orderId)
18241 
      oprot.writeFieldEnd()
18242 
    if self.warehouseId is not None:
18243 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
18244 
      oprot.writeI64(self.warehouseId)
18245 
      oprot.writeFieldEnd()
18246 
    oprot.writeFieldStop()
18247 
    oprot.writeStructEnd()
18248 
 
18249 
  def validate(self):
18250 
    return
18251 
 
18252 
 
18253 
  def __repr__(self):
18254 
    L = ['%s=%r' % (key, value)
18255 
      for key, value in self.__dict__.iteritems()]
18256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18257 
 
18258 
  def __eq__(self, other):
18259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18260 
 
18261 
  def __ne__(self, other):
18262 
    return not (self == other)
18263 
 
18264 
class shiftToWarehouse_result:
18265 
  """
18266 
  Attributes:
18267 
   - success
18268 
   - ex
18269 
  """
18270 
 
18271 
  thrift_spec = (
18272 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18273 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18274 
  )
18275 
 
18276 
  def __init__(self, success=None, ex=None,):
18277 
    self.success = success
18278 
    self.ex = ex
18279 
 
18280 
  def read(self, iprot):
18281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18283 
      return
18284 
    iprot.readStructBegin()
18285 
    while True:
18286 
      (fname, ftype, fid) = iprot.readFieldBegin()
18287 
      if ftype == TType.STOP:
18288 
        break
18289 
      if fid == 0:
18290 
        if ftype == TType.STRUCT:
18291 
          self.success = Order()
18292 
          self.success.read(iprot)
18293 
        else:
18294 
          iprot.skip(ftype)
18295 
      elif fid == 1:
18296 
        if ftype == TType.STRUCT:
18297 
          self.ex = TransactionServiceException()
18298 
          self.ex.read(iprot)
18299 
        else:
18300 
          iprot.skip(ftype)
18301 
      else:
18302 
        iprot.skip(ftype)
18303 
      iprot.readFieldEnd()
18304 
    iprot.readStructEnd()
18305 
 
18306 
  def write(self, oprot):
18307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18309 
      return
18310 
    oprot.writeStructBegin('shiftToWarehouse_result')
18311 
    if self.success is not None:
18312 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18313 
      self.success.write(oprot)
18314 
      oprot.writeFieldEnd()
18315 
    if self.ex is not None:
18316 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18317 
      self.ex.write(oprot)
18318 
      oprot.writeFieldEnd()
18319 
    oprot.writeFieldStop()
18320 
    oprot.writeStructEnd()
18321 
 
18322 
  def validate(self):
18323 
    return
18324 
 
18325 
 
18326 
  def __repr__(self):
18327 
    L = ['%s=%r' % (key, value)
18328 
      for key, value in self.__dict__.iteritems()]
18329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18330 
 
18331 
  def __eq__(self, other):
18332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18333 
 
18334 
  def __ne__(self, other):
18335 
    return not (self == other)
3553 chandransh 18336 
 
18337 
class addDelayReason_args:
18338 
  """
18339 
  Attributes:
18340 
   - orderId
18341 
   - delayReason
3986 chandransh 18342 
   - furtherDelay
4647 rajveer 18343 
   - delayReasonText
3553 chandransh 18344 
  """
18345 
 
18346 
  thrift_spec = (
18347 
    None, # 0
18348 
    (1, TType.I64, 'orderId', None, None, ), # 1
18349 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 18350 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 18351 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 18352 
  )
18353 
 
4647 rajveer 18354 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 18355 
    self.orderId = orderId
18356 
    self.delayReason = delayReason
3986 chandransh 18357 
    self.furtherDelay = furtherDelay
4647 rajveer 18358 
    self.delayReasonText = delayReasonText
3553 chandransh 18359 
 
18360 
  def read(self, iprot):
18361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18363 
      return
18364 
    iprot.readStructBegin()
18365 
    while True:
18366 
      (fname, ftype, fid) = iprot.readFieldBegin()
18367 
      if ftype == TType.STOP:
18368 
        break
18369 
      if fid == 1:
18370 
        if ftype == TType.I64:
18371 
          self.orderId = iprot.readI64();
18372 
        else:
18373 
          iprot.skip(ftype)
18374 
      elif fid == 2:
18375 
        if ftype == TType.I32:
18376 
          self.delayReason = iprot.readI32();
18377 
        else:
18378 
          iprot.skip(ftype)
3986 chandransh 18379 
      elif fid == 3:
18380 
        if ftype == TType.I64:
18381 
          self.furtherDelay = iprot.readI64();
18382 
        else:
18383 
          iprot.skip(ftype)
4647 rajveer 18384 
      elif fid == 4:
18385 
        if ftype == TType.STRING:
18386 
          self.delayReasonText = iprot.readString();
18387 
        else:
18388 
          iprot.skip(ftype)
3553 chandransh 18389 
      else:
18390 
        iprot.skip(ftype)
18391 
      iprot.readFieldEnd()
18392 
    iprot.readStructEnd()
18393 
 
18394 
  def write(self, oprot):
18395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18397 
      return
18398 
    oprot.writeStructBegin('addDelayReason_args')
18399 
    if self.orderId is not None:
18400 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18401 
      oprot.writeI64(self.orderId)
18402 
      oprot.writeFieldEnd()
18403 
    if self.delayReason is not None:
18404 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
18405 
      oprot.writeI32(self.delayReason)
18406 
      oprot.writeFieldEnd()
3986 chandransh 18407 
    if self.furtherDelay is not None:
18408 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
18409 
      oprot.writeI64(self.furtherDelay)
18410 
      oprot.writeFieldEnd()
4647 rajveer 18411 
    if self.delayReasonText is not None:
18412 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
18413 
      oprot.writeString(self.delayReasonText)
18414 
      oprot.writeFieldEnd()
3553 chandransh 18415 
    oprot.writeFieldStop()
18416 
    oprot.writeStructEnd()
18417 
 
18418 
  def validate(self):
18419 
    return
18420 
 
18421 
 
18422 
  def __repr__(self):
18423 
    L = ['%s=%r' % (key, value)
18424 
      for key, value in self.__dict__.iteritems()]
18425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18426 
 
18427 
  def __eq__(self, other):
18428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18429 
 
18430 
  def __ne__(self, other):
18431 
    return not (self == other)
18432 
 
18433 
class addDelayReason_result:
18434 
  """
18435 
  Attributes:
18436 
   - success
18437 
   - ex
18438 
  """
18439 
 
18440 
  thrift_spec = (
18441 
    (0, TType.BOOL, 'success', None, None, ), # 0
18442 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18443 
  )
18444 
 
18445 
  def __init__(self, success=None, ex=None,):
18446 
    self.success = success
18447 
    self.ex = ex
18448 
 
18449 
  def read(self, iprot):
18450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18452 
      return
18453 
    iprot.readStructBegin()
18454 
    while True:
18455 
      (fname, ftype, fid) = iprot.readFieldBegin()
18456 
      if ftype == TType.STOP:
18457 
        break
18458 
      if fid == 0:
18459 
        if ftype == TType.BOOL:
18460 
          self.success = iprot.readBool();
18461 
        else:
18462 
          iprot.skip(ftype)
18463 
      elif fid == 1:
18464 
        if ftype == TType.STRUCT:
18465 
          self.ex = TransactionServiceException()
18466 
          self.ex.read(iprot)
18467 
        else:
18468 
          iprot.skip(ftype)
18469 
      else:
18470 
        iprot.skip(ftype)
18471 
      iprot.readFieldEnd()
18472 
    iprot.readStructEnd()
18473 
 
18474 
  def write(self, oprot):
18475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18477 
      return
18478 
    oprot.writeStructBegin('addDelayReason_result')
18479 
    if self.success is not None:
18480 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18481 
      oprot.writeBool(self.success)
18482 
      oprot.writeFieldEnd()
18483 
    if self.ex is not None:
18484 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18485 
      self.ex.write(oprot)
18486 
      oprot.writeFieldEnd()
18487 
    oprot.writeFieldStop()
18488 
    oprot.writeStructEnd()
18489 
 
18490 
  def validate(self):
18491 
    return
18492 
 
18493 
 
18494 
  def __repr__(self):
18495 
    L = ['%s=%r' % (key, value)
18496 
      for key, value in self.__dict__.iteritems()]
18497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18498 
 
18499 
  def __eq__(self, other):
18500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18501 
 
18502 
  def __ne__(self, other):
18503 
    return not (self == other)
3956 chandransh 18504 
 
18505 
class reconcileCodCollection_args:
18506 
  """
18507 
  Attributes:
18508 
   - collectedAmountMap
18509 
   - xferBy
18510 
   - xferTxnId
18511 
   - xferDate
18512 
  """
18513 
 
18514 
  thrift_spec = (
18515 
    None, # 0
18516 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
18517 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
18518 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
18519 
    (4, TType.I64, 'xferDate', None, None, ), # 4
18520 
  )
18521 
 
18522 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
18523 
    self.collectedAmountMap = collectedAmountMap
18524 
    self.xferBy = xferBy
18525 
    self.xferTxnId = xferTxnId
18526 
    self.xferDate = xferDate
18527 
 
18528 
  def read(self, iprot):
18529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18531 
      return
18532 
    iprot.readStructBegin()
18533 
    while True:
18534 
      (fname, ftype, fid) = iprot.readFieldBegin()
18535 
      if ftype == TType.STOP:
18536 
        break
18537 
      if fid == 1:
18538 
        if ftype == TType.MAP:
18539 
          self.collectedAmountMap = {}
5713 rajveer 18540 
          (_ktype411, _vtype412, _size410 ) = iprot.readMapBegin()
18541 
          for _i414 in xrange(_size410):
18542 
            _key415 = iprot.readString();
18543 
            _val416 = iprot.readDouble();
18544 
            self.collectedAmountMap[_key415] = _val416
3956 chandransh 18545 
          iprot.readMapEnd()
18546 
        else:
18547 
          iprot.skip(ftype)
18548 
      elif fid == 2:
18549 
        if ftype == TType.STRING:
18550 
          self.xferBy = iprot.readString();
18551 
        else:
18552 
          iprot.skip(ftype)
18553 
      elif fid == 3:
18554 
        if ftype == TType.STRING:
18555 
          self.xferTxnId = iprot.readString();
18556 
        else:
18557 
          iprot.skip(ftype)
18558 
      elif fid == 4:
18559 
        if ftype == TType.I64:
18560 
          self.xferDate = iprot.readI64();
18561 
        else:
18562 
          iprot.skip(ftype)
18563 
      else:
18564 
        iprot.skip(ftype)
18565 
      iprot.readFieldEnd()
18566 
    iprot.readStructEnd()
18567 
 
18568 
  def write(self, oprot):
18569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18571 
      return
18572 
    oprot.writeStructBegin('reconcileCodCollection_args')
18573 
    if self.collectedAmountMap is not None:
18574 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
18575 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5713 rajveer 18576 
      for kiter417,viter418 in self.collectedAmountMap.items():
18577 
        oprot.writeString(kiter417)
18578 
        oprot.writeDouble(viter418)
3956 chandransh 18579 
      oprot.writeMapEnd()
18580 
      oprot.writeFieldEnd()
18581 
    if self.xferBy is not None:
18582 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
18583 
      oprot.writeString(self.xferBy)
18584 
      oprot.writeFieldEnd()
18585 
    if self.xferTxnId is not None:
18586 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
18587 
      oprot.writeString(self.xferTxnId)
18588 
      oprot.writeFieldEnd()
18589 
    if self.xferDate is not None:
18590 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
18591 
      oprot.writeI64(self.xferDate)
18592 
      oprot.writeFieldEnd()
18593 
    oprot.writeFieldStop()
18594 
    oprot.writeStructEnd()
18595 
 
18596 
  def validate(self):
18597 
    return
18598 
 
18599 
 
18600 
  def __repr__(self):
18601 
    L = ['%s=%r' % (key, value)
18602 
      for key, value in self.__dict__.iteritems()]
18603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18604 
 
18605 
  def __eq__(self, other):
18606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18607 
 
18608 
  def __ne__(self, other):
18609 
    return not (self == other)
18610 
 
18611 
class reconcileCodCollection_result:
18612 
  """
18613 
  Attributes:
18614 
   - success
18615 
   - ex
18616 
  """
18617 
 
18618 
  thrift_spec = (
18619 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
18620 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18621 
  )
18622 
 
18623 
  def __init__(self, success=None, ex=None,):
18624 
    self.success = success
18625 
    self.ex = ex
18626 
 
18627 
  def read(self, iprot):
18628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18630 
      return
18631 
    iprot.readStructBegin()
18632 
    while True:
18633 
      (fname, ftype, fid) = iprot.readFieldBegin()
18634 
      if ftype == TType.STOP:
18635 
        break
18636 
      if fid == 0:
18637 
        if ftype == TType.MAP:
18638 
          self.success = {}
5713 rajveer 18639 
          (_ktype420, _vtype421, _size419 ) = iprot.readMapBegin()
18640 
          for _i423 in xrange(_size419):
18641 
            _key424 = iprot.readString();
18642 
            _val425 = iprot.readString();
18643 
            self.success[_key424] = _val425
3956 chandransh 18644 
          iprot.readMapEnd()
18645 
        else:
18646 
          iprot.skip(ftype)
18647 
      elif fid == 1:
18648 
        if ftype == TType.STRUCT:
18649 
          self.ex = TransactionServiceException()
18650 
          self.ex.read(iprot)
18651 
        else:
18652 
          iprot.skip(ftype)
18653 
      else:
18654 
        iprot.skip(ftype)
18655 
      iprot.readFieldEnd()
18656 
    iprot.readStructEnd()
18657 
 
18658 
  def write(self, oprot):
18659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18661 
      return
18662 
    oprot.writeStructBegin('reconcileCodCollection_result')
18663 
    if self.success is not None:
18664 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18665 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5713 rajveer 18666 
      for kiter426,viter427 in self.success.items():
18667 
        oprot.writeString(kiter426)
18668 
        oprot.writeString(viter427)
3956 chandransh 18669 
      oprot.writeMapEnd()
18670 
      oprot.writeFieldEnd()
18671 
    if self.ex is not None:
18672 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18673 
      self.ex.write(oprot)
18674 
      oprot.writeFieldEnd()
18675 
    oprot.writeFieldStop()
18676 
    oprot.writeStructEnd()
18677 
 
18678 
  def validate(self):
18679 
    return
18680 
 
18681 
 
18682 
  def __repr__(self):
18683 
    L = ['%s=%r' % (key, value)
18684 
      for key, value in self.__dict__.iteritems()]
18685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18686 
 
18687 
  def __eq__(self, other):
18688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18689 
 
18690 
  def __ne__(self, other):
18691 
    return not (self == other)
4008 mandeep.dh 18692 
 
18693 
class getTransactionsRequiringExtraProcessing_args:
18694 
  """
18695 
  Attributes:
18696 
   - category
18697 
  """
18698 
 
18699 
  thrift_spec = (
18700 
    None, # 0
18701 
    (1, TType.I32, 'category', None, None, ), # 1
18702 
  )
18703 
 
18704 
  def __init__(self, category=None,):
18705 
    self.category = category
18706 
 
18707 
  def read(self, iprot):
18708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18710 
      return
18711 
    iprot.readStructBegin()
18712 
    while True:
18713 
      (fname, ftype, fid) = iprot.readFieldBegin()
18714 
      if ftype == TType.STOP:
18715 
        break
18716 
      if fid == 1:
18717 
        if ftype == TType.I32:
18718 
          self.category = iprot.readI32();
18719 
        else:
18720 
          iprot.skip(ftype)
18721 
      else:
18722 
        iprot.skip(ftype)
18723 
      iprot.readFieldEnd()
18724 
    iprot.readStructEnd()
18725 
 
18726 
  def write(self, oprot):
18727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18729 
      return
18730 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
18731 
    if self.category is not None:
18732 
      oprot.writeFieldBegin('category', TType.I32, 1)
18733 
      oprot.writeI32(self.category)
18734 
      oprot.writeFieldEnd()
18735 
    oprot.writeFieldStop()
18736 
    oprot.writeStructEnd()
18737 
 
18738 
  def validate(self):
18739 
    return
18740 
 
18741 
 
18742 
  def __repr__(self):
18743 
    L = ['%s=%r' % (key, value)
18744 
      for key, value in self.__dict__.iteritems()]
18745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18746 
 
18747 
  def __eq__(self, other):
18748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18749 
 
18750 
  def __ne__(self, other):
18751 
    return not (self == other)
18752 
 
18753 
class getTransactionsRequiringExtraProcessing_result:
18754 
  """
18755 
  Attributes:
18756 
   - success
18757 
  """
18758 
 
18759 
  thrift_spec = (
18760 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
18761 
  )
18762 
 
18763 
  def __init__(self, success=None,):
18764 
    self.success = success
18765 
 
18766 
  def read(self, iprot):
18767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18769 
      return
18770 
    iprot.readStructBegin()
18771 
    while True:
18772 
      (fname, ftype, fid) = iprot.readFieldBegin()
18773 
      if ftype == TType.STOP:
18774 
        break
18775 
      if fid == 0:
18776 
        if ftype == TType.LIST:
18777 
          self.success = []
5713 rajveer 18778 
          (_etype431, _size428) = iprot.readListBegin()
18779 
          for _i432 in xrange(_size428):
18780 
            _elem433 = iprot.readI64();
18781 
            self.success.append(_elem433)
4008 mandeep.dh 18782 
          iprot.readListEnd()
18783 
        else:
18784 
          iprot.skip(ftype)
18785 
      else:
18786 
        iprot.skip(ftype)
18787 
      iprot.readFieldEnd()
18788 
    iprot.readStructEnd()
18789 
 
18790 
  def write(self, oprot):
18791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18793 
      return
18794 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
18795 
    if self.success is not None:
18796 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18797 
      oprot.writeListBegin(TType.I64, len(self.success))
5713 rajveer 18798 
      for iter434 in self.success:
18799 
        oprot.writeI64(iter434)
4008 mandeep.dh 18800 
      oprot.writeListEnd()
18801 
      oprot.writeFieldEnd()
18802 
    oprot.writeFieldStop()
18803 
    oprot.writeStructEnd()
18804 
 
18805 
  def validate(self):
18806 
    return
18807 
 
18808 
 
18809 
  def __repr__(self):
18810 
    L = ['%s=%r' % (key, value)
18811 
      for key, value in self.__dict__.iteritems()]
18812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18813 
 
18814 
  def __eq__(self, other):
18815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18816 
 
18817 
  def __ne__(self, other):
18818 
    return not (self == other)
18819 
 
18820 
class markTransactionAsProcessed_args:
18821 
  """
18822 
  Attributes:
18823 
   - transactionId
18824 
   - category
18825 
  """
18826 
 
18827 
  thrift_spec = (
18828 
    None, # 0
18829 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18830 
    (2, TType.I32, 'category', None, None, ), # 2
18831 
  )
18832 
 
18833 
  def __init__(self, transactionId=None, category=None,):
18834 
    self.transactionId = transactionId
18835 
    self.category = category
18836 
 
18837 
  def read(self, iprot):
18838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18840 
      return
18841 
    iprot.readStructBegin()
18842 
    while True:
18843 
      (fname, ftype, fid) = iprot.readFieldBegin()
18844 
      if ftype == TType.STOP:
18845 
        break
18846 
      if fid == 1:
18847 
        if ftype == TType.I64:
18848 
          self.transactionId = iprot.readI64();
18849 
        else:
18850 
          iprot.skip(ftype)
18851 
      elif fid == 2:
18852 
        if ftype == TType.I32:
18853 
          self.category = iprot.readI32();
18854 
        else:
18855 
          iprot.skip(ftype)
18856 
      else:
18857 
        iprot.skip(ftype)
18858 
      iprot.readFieldEnd()
18859 
    iprot.readStructEnd()
18860 
 
18861 
  def write(self, oprot):
18862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18864 
      return
18865 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
18866 
    if self.transactionId is not None:
18867 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18868 
      oprot.writeI64(self.transactionId)
18869 
      oprot.writeFieldEnd()
18870 
    if self.category is not None:
18871 
      oprot.writeFieldBegin('category', TType.I32, 2)
18872 
      oprot.writeI32(self.category)
18873 
      oprot.writeFieldEnd()
18874 
    oprot.writeFieldStop()
18875 
    oprot.writeStructEnd()
18876 
 
18877 
  def validate(self):
18878 
    return
18879 
 
18880 
 
18881 
  def __repr__(self):
18882 
    L = ['%s=%r' % (key, value)
18883 
      for key, value in self.__dict__.iteritems()]
18884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18885 
 
18886 
  def __eq__(self, other):
18887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18888 
 
18889 
  def __ne__(self, other):
18890 
    return not (self == other)
18891 
 
18892 
class markTransactionAsProcessed_result:
18893 
 
18894 
  thrift_spec = (
18895 
  )
18896 
 
18897 
  def read(self, iprot):
18898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18900 
      return
18901 
    iprot.readStructBegin()
18902 
    while True:
18903 
      (fname, ftype, fid) = iprot.readFieldBegin()
18904 
      if ftype == TType.STOP:
18905 
        break
18906 
      else:
18907 
        iprot.skip(ftype)
18908 
      iprot.readFieldEnd()
18909 
    iprot.readStructEnd()
18910 
 
18911 
  def write(self, oprot):
18912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18914 
      return
18915 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
18916 
    oprot.writeFieldStop()
18917 
    oprot.writeStructEnd()
18918 
 
18919 
  def validate(self):
18920 
    return
18921 
 
18922 
 
18923 
  def __repr__(self):
18924 
    L = ['%s=%r' % (key, value)
18925 
      for key, value in self.__dict__.iteritems()]
18926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18927 
 
18928 
  def __eq__(self, other):
18929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18930 
 
18931 
  def __ne__(self, other):
18932 
    return not (self == other)
4018 chandransh 18933 
 
18934 
class getItemWiseRiskyOrdersCount_args:
18935 
 
18936 
  thrift_spec = (
18937 
  )
18938 
 
18939 
  def read(self, iprot):
18940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18942 
      return
18943 
    iprot.readStructBegin()
18944 
    while True:
18945 
      (fname, ftype, fid) = iprot.readFieldBegin()
18946 
      if ftype == TType.STOP:
18947 
        break
18948 
      else:
18949 
        iprot.skip(ftype)
18950 
      iprot.readFieldEnd()
18951 
    iprot.readStructEnd()
18952 
 
18953 
  def write(self, oprot):
18954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18956 
      return
18957 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
18958 
    oprot.writeFieldStop()
18959 
    oprot.writeStructEnd()
18960 
 
18961 
  def validate(self):
18962 
    return
18963 
 
18964 
 
18965 
  def __repr__(self):
18966 
    L = ['%s=%r' % (key, value)
18967 
      for key, value in self.__dict__.iteritems()]
18968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18969 
 
18970 
  def __eq__(self, other):
18971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18972 
 
18973 
  def __ne__(self, other):
18974 
    return not (self == other)
18975 
 
18976 
class getItemWiseRiskyOrdersCount_result:
18977 
  """
18978 
  Attributes:
18979 
   - success
18980 
  """
18981 
 
18982 
  thrift_spec = (
18983 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
18984 
  )
18985 
 
18986 
  def __init__(self, success=None,):
18987 
    self.success = success
18988 
 
18989 
  def read(self, iprot):
18990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18992 
      return
18993 
    iprot.readStructBegin()
18994 
    while True:
18995 
      (fname, ftype, fid) = iprot.readFieldBegin()
18996 
      if ftype == TType.STOP:
18997 
        break
18998 
      if fid == 0:
18999 
        if ftype == TType.MAP:
19000 
          self.success = {}
5713 rajveer 19001 
          (_ktype436, _vtype437, _size435 ) = iprot.readMapBegin()
19002 
          for _i439 in xrange(_size435):
19003 
            _key440 = iprot.readI64();
19004 
            _val441 = iprot.readI64();
19005 
            self.success[_key440] = _val441
4018 chandransh 19006 
          iprot.readMapEnd()
19007 
        else:
19008 
          iprot.skip(ftype)
19009 
      else:
19010 
        iprot.skip(ftype)
19011 
      iprot.readFieldEnd()
19012 
    iprot.readStructEnd()
19013 
 
19014 
  def write(self, oprot):
19015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19017 
      return
19018 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
19019 
    if self.success is not None:
19020 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19021 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5713 rajveer 19022 
      for kiter442,viter443 in self.success.items():
19023 
        oprot.writeI64(kiter442)
19024 
        oprot.writeI64(viter443)
4018 chandransh 19025 
      oprot.writeMapEnd()
19026 
      oprot.writeFieldEnd()
19027 
    oprot.writeFieldStop()
19028 
    oprot.writeStructEnd()
19029 
 
19030 
  def validate(self):
19031 
    return
19032 
 
19033 
 
19034 
  def __repr__(self):
19035 
    L = ['%s=%r' % (key, value)
19036 
      for key, value in self.__dict__.iteritems()]
19037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19038 
 
19039 
  def __eq__(self, other):
19040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19041 
 
19042 
  def __ne__(self, other):
19043 
    return not (self == other)
4247 rajveer 19044 
 
4295 varun.gupt 19045 
class getOrdersForItemIds_args:
19046 
  """
19047 
  Attributes:
19048 
   - itemIds
19049 
  """
19050 
 
19051 
  thrift_spec = (
19052 
    None, # 0
19053 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19054 
  )
19055 
 
19056 
  def __init__(self, itemIds=None,):
19057 
    self.itemIds = itemIds
19058 
 
19059 
  def read(self, iprot):
19060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19062 
      return
19063 
    iprot.readStructBegin()
19064 
    while True:
19065 
      (fname, ftype, fid) = iprot.readFieldBegin()
19066 
      if ftype == TType.STOP:
19067 
        break
19068 
      if fid == 1:
19069 
        if ftype == TType.LIST:
19070 
          self.itemIds = []
5713 rajveer 19071 
          (_etype447, _size444) = iprot.readListBegin()
19072 
          for _i448 in xrange(_size444):
19073 
            _elem449 = iprot.readI64();
19074 
            self.itemIds.append(_elem449)
4295 varun.gupt 19075 
          iprot.readListEnd()
19076 
        else:
19077 
          iprot.skip(ftype)
19078 
      else:
19079 
        iprot.skip(ftype)
19080 
      iprot.readFieldEnd()
19081 
    iprot.readStructEnd()
19082 
 
19083 
  def write(self, oprot):
19084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19086 
      return
19087 
    oprot.writeStructBegin('getOrdersForItemIds_args')
19088 
    if self.itemIds is not None:
19089 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19090 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5713 rajveer 19091 
      for iter450 in self.itemIds:
19092 
        oprot.writeI64(iter450)
4295 varun.gupt 19093 
      oprot.writeListEnd()
19094 
      oprot.writeFieldEnd()
19095 
    oprot.writeFieldStop()
19096 
    oprot.writeStructEnd()
19097 
 
19098 
  def validate(self):
19099 
    return
19100 
 
19101 
 
19102 
  def __repr__(self):
19103 
    L = ['%s=%r' % (key, value)
19104 
      for key, value in self.__dict__.iteritems()]
19105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19106 
 
19107 
  def __eq__(self, other):
19108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19109 
 
19110 
  def __ne__(self, other):
19111 
    return not (self == other)
19112 
 
19113 
class getOrdersForItemIds_result:
19114 
  """
19115 
  Attributes:
19116 
   - success
19117 
  """
19118 
 
19119 
  thrift_spec = (
19120 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19121 
  )
19122 
 
19123 
  def __init__(self, success=None,):
19124 
    self.success = success
19125 
 
19126 
  def read(self, iprot):
19127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19129 
      return
19130 
    iprot.readStructBegin()
19131 
    while True:
19132 
      (fname, ftype, fid) = iprot.readFieldBegin()
19133 
      if ftype == TType.STOP:
19134 
        break
19135 
      if fid == 0:
19136 
        if ftype == TType.LIST:
19137 
          self.success = []
5713 rajveer 19138 
          (_etype454, _size451) = iprot.readListBegin()
19139 
          for _i455 in xrange(_size451):
19140 
            _elem456 = Order()
19141 
            _elem456.read(iprot)
19142 
            self.success.append(_elem456)
4295 varun.gupt 19143 
          iprot.readListEnd()
19144 
        else:
19145 
          iprot.skip(ftype)
19146 
      else:
19147 
        iprot.skip(ftype)
19148 
      iprot.readFieldEnd()
19149 
    iprot.readStructEnd()
19150 
 
19151 
  def write(self, oprot):
19152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19154 
      return
19155 
    oprot.writeStructBegin('getOrdersForItemIds_result')
19156 
    if self.success is not None:
19157 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19158 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 19159 
      for iter457 in self.success:
19160 
        iter457.write(oprot)
4295 varun.gupt 19161 
      oprot.writeListEnd()
19162 
      oprot.writeFieldEnd()
19163 
    oprot.writeFieldStop()
19164 
    oprot.writeStructEnd()
19165 
 
19166 
  def validate(self):
19167 
    return
19168 
 
19169 
 
19170 
  def __repr__(self):
19171 
    L = ['%s=%r' % (key, value)
19172 
      for key, value in self.__dict__.iteritems()]
19173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19174 
 
19175 
  def __eq__(self, other):
19176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19177 
 
19178 
  def __ne__(self, other):
19179 
    return not (self == other)
19180 
 
4247 rajveer 19181 
class markOrderCancellationRequestReceived_args:
19182 
  """
19183 
  Attributes:
19184 
   - orderId
19185 
  """
19186 
 
19187 
  thrift_spec = (
19188 
    None, # 0
19189 
    (1, TType.I64, 'orderId', None, None, ), # 1
19190 
  )
19191 
 
19192 
  def __init__(self, orderId=None,):
19193 
    self.orderId = orderId
19194 
 
19195 
  def read(self, iprot):
19196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19198 
      return
19199 
    iprot.readStructBegin()
19200 
    while True:
19201 
      (fname, ftype, fid) = iprot.readFieldBegin()
19202 
      if ftype == TType.STOP:
19203 
        break
19204 
      if fid == 1:
19205 
        if ftype == TType.I64:
19206 
          self.orderId = iprot.readI64();
19207 
        else:
19208 
          iprot.skip(ftype)
19209 
      else:
19210 
        iprot.skip(ftype)
19211 
      iprot.readFieldEnd()
19212 
    iprot.readStructEnd()
19213 
 
19214 
  def write(self, oprot):
19215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19217 
      return
19218 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
19219 
    if self.orderId is not None:
19220 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19221 
      oprot.writeI64(self.orderId)
19222 
      oprot.writeFieldEnd()
19223 
    oprot.writeFieldStop()
19224 
    oprot.writeStructEnd()
19225 
 
19226 
  def validate(self):
19227 
    return
19228 
 
19229 
 
19230 
  def __repr__(self):
19231 
    L = ['%s=%r' % (key, value)
19232 
      for key, value in self.__dict__.iteritems()]
19233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19234 
 
19235 
  def __eq__(self, other):
19236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19237 
 
19238 
  def __ne__(self, other):
19239 
    return not (self == other)
19240 
 
19241 
class markOrderCancellationRequestReceived_result:
19242 
  """
19243 
  Attributes:
19244 
   - ex
19245 
  """
19246 
 
19247 
  thrift_spec = (
19248 
    None, # 0
19249 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19250 
  )
19251 
 
19252 
  def __init__(self, ex=None,):
19253 
    self.ex = ex
19254 
 
19255 
  def read(self, iprot):
19256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19258 
      return
19259 
    iprot.readStructBegin()
19260 
    while True:
19261 
      (fname, ftype, fid) = iprot.readFieldBegin()
19262 
      if ftype == TType.STOP:
19263 
        break
19264 
      if fid == 1:
19265 
        if ftype == TType.STRUCT:
19266 
          self.ex = TransactionServiceException()
19267 
          self.ex.read(iprot)
19268 
        else:
19269 
          iprot.skip(ftype)
19270 
      else:
19271 
        iprot.skip(ftype)
19272 
      iprot.readFieldEnd()
19273 
    iprot.readStructEnd()
19274 
 
19275 
  def write(self, oprot):
19276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19278 
      return
19279 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
19280 
    if self.ex is not None:
19281 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19282 
      self.ex.write(oprot)
19283 
      oprot.writeFieldEnd()
19284 
    oprot.writeFieldStop()
19285 
    oprot.writeStructEnd()
19286 
 
19287 
  def validate(self):
19288 
    return
19289 
 
19290 
 
19291 
  def __repr__(self):
19292 
    L = ['%s=%r' % (key, value)
19293 
      for key, value in self.__dict__.iteritems()]
19294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19295 
 
19296 
  def __eq__(self, other):
19297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19298 
 
19299 
  def __ne__(self, other):
19300 
    return not (self == other)
19301 
 
19302 
class markOrderCancellationRequestConfirmed_args:
19303 
  """
19304 
  Attributes:
19305 
   - orderId
19306 
  """
19307 
 
19308 
  thrift_spec = (
19309 
    None, # 0
19310 
    (1, TType.I64, 'orderId', None, None, ), # 1
19311 
  )
19312 
 
19313 
  def __init__(self, orderId=None,):
19314 
    self.orderId = orderId
19315 
 
19316 
  def read(self, iprot):
19317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19319 
      return
19320 
    iprot.readStructBegin()
19321 
    while True:
19322 
      (fname, ftype, fid) = iprot.readFieldBegin()
19323 
      if ftype == TType.STOP:
19324 
        break
19325 
      if fid == 1:
19326 
        if ftype == TType.I64:
19327 
          self.orderId = iprot.readI64();
19328 
        else:
19329 
          iprot.skip(ftype)
19330 
      else:
19331 
        iprot.skip(ftype)
19332 
      iprot.readFieldEnd()
19333 
    iprot.readStructEnd()
19334 
 
19335 
  def write(self, oprot):
19336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19338 
      return
19339 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
19340 
    if self.orderId is not None:
19341 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19342 
      oprot.writeI64(self.orderId)
19343 
      oprot.writeFieldEnd()
19344 
    oprot.writeFieldStop()
19345 
    oprot.writeStructEnd()
19346 
 
19347 
  def validate(self):
19348 
    return
19349 
 
19350 
 
19351 
  def __repr__(self):
19352 
    L = ['%s=%r' % (key, value)
19353 
      for key, value in self.__dict__.iteritems()]
19354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19355 
 
19356 
  def __eq__(self, other):
19357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19358 
 
19359 
  def __ne__(self, other):
19360 
    return not (self == other)
19361 
 
19362 
class markOrderCancellationRequestConfirmed_result:
19363 
  """
19364 
  Attributes:
19365 
   - ex
19366 
  """
19367 
 
19368 
  thrift_spec = (
19369 
    None, # 0
19370 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19371 
  )
19372 
 
19373 
  def __init__(self, ex=None,):
19374 
    self.ex = ex
19375 
 
19376 
  def read(self, iprot):
19377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19379 
      return
19380 
    iprot.readStructBegin()
19381 
    while True:
19382 
      (fname, ftype, fid) = iprot.readFieldBegin()
19383 
      if ftype == TType.STOP:
19384 
        break
19385 
      if fid == 1:
19386 
        if ftype == TType.STRUCT:
19387 
          self.ex = TransactionServiceException()
19388 
          self.ex.read(iprot)
19389 
        else:
19390 
          iprot.skip(ftype)
19391 
      else:
19392 
        iprot.skip(ftype)
19393 
      iprot.readFieldEnd()
19394 
    iprot.readStructEnd()
19395 
 
19396 
  def write(self, oprot):
19397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19399 
      return
19400 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
19401 
    if self.ex is not None:
19402 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19403 
      self.ex.write(oprot)
19404 
      oprot.writeFieldEnd()
19405 
    oprot.writeFieldStop()
19406 
    oprot.writeStructEnd()
19407 
 
19408 
  def validate(self):
19409 
    return
19410 
 
19411 
 
19412 
  def __repr__(self):
19413 
    L = ['%s=%r' % (key, value)
19414 
      for key, value in self.__dict__.iteritems()]
19415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19416 
 
19417 
  def __eq__(self, other):
19418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19419 
 
19420 
  def __ne__(self, other):
19421 
    return not (self == other)
19422 
 
19423 
class markOrderCancellationRequestDenied_args:
19424 
  """
19425 
  Attributes:
19426 
   - orderId
19427 
  """
19428 
 
19429 
  thrift_spec = (
19430 
    None, # 0
19431 
    (1, TType.I64, 'orderId', None, None, ), # 1
19432 
  )
19433 
 
19434 
  def __init__(self, orderId=None,):
19435 
    self.orderId = orderId
19436 
 
19437 
  def read(self, iprot):
19438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19440 
      return
19441 
    iprot.readStructBegin()
19442 
    while True:
19443 
      (fname, ftype, fid) = iprot.readFieldBegin()
19444 
      if ftype == TType.STOP:
19445 
        break
19446 
      if fid == 1:
19447 
        if ftype == TType.I64:
19448 
          self.orderId = iprot.readI64();
19449 
        else:
19450 
          iprot.skip(ftype)
19451 
      else:
19452 
        iprot.skip(ftype)
19453 
      iprot.readFieldEnd()
19454 
    iprot.readStructEnd()
19455 
 
19456 
  def write(self, oprot):
19457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19459 
      return
19460 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
19461 
    if self.orderId is not None:
19462 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19463 
      oprot.writeI64(self.orderId)
19464 
      oprot.writeFieldEnd()
19465 
    oprot.writeFieldStop()
19466 
    oprot.writeStructEnd()
19467 
 
19468 
  def validate(self):
19469 
    return
19470 
 
19471 
 
19472 
  def __repr__(self):
19473 
    L = ['%s=%r' % (key, value)
19474 
      for key, value in self.__dict__.iteritems()]
19475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19476 
 
19477 
  def __eq__(self, other):
19478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19479 
 
19480 
  def __ne__(self, other):
19481 
    return not (self == other)
19482 
 
19483 
class markOrderCancellationRequestDenied_result:
19484 
  """
19485 
  Attributes:
19486 
   - ex
19487 
  """
19488 
 
19489 
  thrift_spec = (
19490 
    None, # 0
19491 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19492 
  )
19493 
 
19494 
  def __init__(self, ex=None,):
19495 
    self.ex = ex
19496 
 
19497 
  def read(self, iprot):
19498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19500 
      return
19501 
    iprot.readStructBegin()
19502 
    while True:
19503 
      (fname, ftype, fid) = iprot.readFieldBegin()
19504 
      if ftype == TType.STOP:
19505 
        break
19506 
      if fid == 1:
19507 
        if ftype == TType.STRUCT:
19508 
          self.ex = TransactionServiceException()
19509 
          self.ex.read(iprot)
19510 
        else:
19511 
          iprot.skip(ftype)
19512 
      else:
19513 
        iprot.skip(ftype)
19514 
      iprot.readFieldEnd()
19515 
    iprot.readStructEnd()
19516 
 
19517 
  def write(self, oprot):
19518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19520 
      return
19521 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
19522 
    if self.ex is not None:
19523 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19524 
      self.ex.write(oprot)
19525 
      oprot.writeFieldEnd()
19526 
    oprot.writeFieldStop()
19527 
    oprot.writeStructEnd()
19528 
 
19529 
  def validate(self):
19530 
    return
19531 
 
19532 
 
19533 
  def __repr__(self):
19534 
    L = ['%s=%r' % (key, value)
19535 
      for key, value in self.__dict__.iteritems()]
19536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19537 
 
19538 
  def __eq__(self, other):
19539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19540 
 
19541 
  def __ne__(self, other):
19542 
    return not (self == other)
19543 
 
4258 rajveer 19544 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 19545 
  """
19546 
  Attributes:
4258 rajveer 19547 
   - transactionId
4247 rajveer 19548 
  """
19549 
 
19550 
  thrift_spec = (
19551 
    None, # 0
4258 rajveer 19552 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 19553 
  )
19554 
 
4258 rajveer 19555 
  def __init__(self, transactionId=None,):
19556 
    self.transactionId = transactionId
4247 rajveer 19557 
 
19558 
  def read(self, iprot):
19559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19561 
      return
19562 
    iprot.readStructBegin()
19563 
    while True:
19564 
      (fname, ftype, fid) = iprot.readFieldBegin()
19565 
      if ftype == TType.STOP:
19566 
        break
19567 
      if fid == 1:
19568 
        if ftype == TType.I64:
4258 rajveer 19569 
          self.transactionId = iprot.readI64();
4247 rajveer 19570 
        else:
19571 
          iprot.skip(ftype)
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
4258 rajveer 19581 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
19582 
    if self.transactionId is not None:
19583 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19584 
      oprot.writeI64(self.transactionId)
4247 rajveer 19585 
      oprot.writeFieldEnd()
19586 
    oprot.writeFieldStop()
19587 
    oprot.writeStructEnd()
19588 
 
19589 
  def validate(self):
19590 
    return
19591 
 
19592 
 
19593 
  def __repr__(self):
19594 
    L = ['%s=%r' % (key, value)
19595 
      for key, value in self.__dict__.iteritems()]
19596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19597 
 
19598 
  def __eq__(self, other):
19599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19600 
 
19601 
  def __ne__(self, other):
19602 
    return not (self == other)
19603 
 
4258 rajveer 19604 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 19605 
  """
19606 
  Attributes:
19607 
   - ex
19608 
  """
19609 
 
19610 
  thrift_spec = (
19611 
    None, # 0
19612 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19613 
  )
19614 
 
19615 
  def __init__(self, ex=None,):
19616 
    self.ex = ex
19617 
 
19618 
  def read(self, iprot):
19619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19621 
      return
19622 
    iprot.readStructBegin()
19623 
    while True:
19624 
      (fname, ftype, fid) = iprot.readFieldBegin()
19625 
      if ftype == TType.STOP:
19626 
        break
19627 
      if fid == 1:
19628 
        if ftype == TType.STRUCT:
19629 
          self.ex = TransactionServiceException()
19630 
          self.ex.read(iprot)
19631 
        else:
19632 
          iprot.skip(ftype)
19633 
      else:
19634 
        iprot.skip(ftype)
19635 
      iprot.readFieldEnd()
19636 
    iprot.readStructEnd()
19637 
 
19638 
  def write(self, oprot):
19639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19641 
      return
4258 rajveer 19642 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 19643 
    if self.ex is not None:
19644 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19645 
      self.ex.write(oprot)
19646 
      oprot.writeFieldEnd()
19647 
    oprot.writeFieldStop()
19648 
    oprot.writeStructEnd()
19649 
 
19650 
  def validate(self):
19651 
    return
19652 
 
19653 
 
19654 
  def __repr__(self):
19655 
    L = ['%s=%r' % (key, value)
19656 
      for key, value in self.__dict__.iteritems()]
19657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19658 
 
19659 
  def __eq__(self, other):
19660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19661 
 
19662 
  def __ne__(self, other):
19663 
    return not (self == other)
4259 anupam.sin 19664 
 
19665 
class refundTransaction_args:
19666 
  """
19667 
  Attributes:
19668 
   - transactionId
19669 
   - refundedBy
19670 
   - reason
19671 
  """
19672 
 
19673 
  thrift_spec = (
19674 
    None, # 0
19675 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19676 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19677 
    (3, TType.STRING, 'reason', None, None, ), # 3
19678 
  )
19679 
 
19680 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
19681 
    self.transactionId = transactionId
19682 
    self.refundedBy = refundedBy
19683 
    self.reason = reason
19684 
 
19685 
  def read(self, iprot):
19686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19688 
      return
19689 
    iprot.readStructBegin()
19690 
    while True:
19691 
      (fname, ftype, fid) = iprot.readFieldBegin()
19692 
      if ftype == TType.STOP:
19693 
        break
19694 
      if fid == 1:
19695 
        if ftype == TType.I64:
19696 
          self.transactionId = iprot.readI64();
19697 
        else:
19698 
          iprot.skip(ftype)
19699 
      elif fid == 2:
19700 
        if ftype == TType.STRING:
19701 
          self.refundedBy = iprot.readString();
19702 
        else:
19703 
          iprot.skip(ftype)
19704 
      elif fid == 3:
19705 
        if ftype == TType.STRING:
19706 
          self.reason = iprot.readString();
19707 
        else:
19708 
          iprot.skip(ftype)
19709 
      else:
19710 
        iprot.skip(ftype)
19711 
      iprot.readFieldEnd()
19712 
    iprot.readStructEnd()
19713 
 
19714 
  def write(self, oprot):
19715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19717 
      return
19718 
    oprot.writeStructBegin('refundTransaction_args')
19719 
    if self.transactionId is not None:
19720 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19721 
      oprot.writeI64(self.transactionId)
19722 
      oprot.writeFieldEnd()
19723 
    if self.refundedBy is not None:
19724 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
19725 
      oprot.writeString(self.refundedBy)
19726 
      oprot.writeFieldEnd()
19727 
    if self.reason is not None:
19728 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
19729 
      oprot.writeString(self.reason)
19730 
      oprot.writeFieldEnd()
19731 
    oprot.writeFieldStop()
19732 
    oprot.writeStructEnd()
19733 
 
19734 
  def validate(self):
19735 
    return
19736 
 
19737 
 
19738 
  def __repr__(self):
19739 
    L = ['%s=%r' % (key, value)
19740 
      for key, value in self.__dict__.iteritems()]
19741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19742 
 
19743 
  def __eq__(self, other):
19744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19745 
 
19746 
  def __ne__(self, other):
19747 
    return not (self == other)
19748 
 
19749 
class refundTransaction_result:
19750 
  """
19751 
  Attributes:
19752 
   - ex
19753 
  """
19754 
 
19755 
  thrift_spec = (
19756 
    None, # 0
19757 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19758 
  )
19759 
 
19760 
  def __init__(self, ex=None,):
19761 
    self.ex = ex
19762 
 
19763 
  def read(self, iprot):
19764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19766 
      return
19767 
    iprot.readStructBegin()
19768 
    while True:
19769 
      (fname, ftype, fid) = iprot.readFieldBegin()
19770 
      if ftype == TType.STOP:
19771 
        break
19772 
      if fid == 1:
19773 
        if ftype == TType.STRUCT:
19774 
          self.ex = TransactionServiceException()
19775 
          self.ex.read(iprot)
19776 
        else:
19777 
          iprot.skip(ftype)
19778 
      else:
19779 
        iprot.skip(ftype)
19780 
      iprot.readFieldEnd()
19781 
    iprot.readStructEnd()
19782 
 
19783 
  def write(self, oprot):
19784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19786 
      return
19787 
    oprot.writeStructBegin('refundTransaction_result')
19788 
    if self.ex is not None:
19789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19790 
      self.ex.write(oprot)
19791 
      oprot.writeFieldEnd()
19792 
    oprot.writeFieldStop()
19793 
    oprot.writeStructEnd()
19794 
 
19795 
  def validate(self):
19796 
    return
19797 
 
19798 
 
19799 
  def __repr__(self):
19800 
    L = ['%s=%r' % (key, value)
19801 
      for key, value in self.__dict__.iteritems()]
19802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19803 
 
19804 
  def __eq__(self, other):
19805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19806 
 
19807 
  def __ne__(self, other):
19808 
    return not (self == other)
4285 rajveer 19809 
 
4324 mandeep.dh 19810 
class updateShipmentAddress_args:
19811 
  """
19812 
  Attributes:
19813 
   - orderId
19814 
   - addressId
19815 
  """
19816 
 
19817 
  thrift_spec = (
19818 
    None, # 0
19819 
    (1, TType.I64, 'orderId', None, None, ), # 1
19820 
    (2, TType.I64, 'addressId', None, None, ), # 2
19821 
  )
19822 
 
19823 
  def __init__(self, orderId=None, addressId=None,):
19824 
    self.orderId = orderId
19825 
    self.addressId = addressId
19826 
 
19827 
  def read(self, iprot):
19828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19830 
      return
19831 
    iprot.readStructBegin()
19832 
    while True:
19833 
      (fname, ftype, fid) = iprot.readFieldBegin()
19834 
      if ftype == TType.STOP:
19835 
        break
19836 
      if fid == 1:
19837 
        if ftype == TType.I64:
19838 
          self.orderId = iprot.readI64();
19839 
        else:
19840 
          iprot.skip(ftype)
19841 
      elif fid == 2:
19842 
        if ftype == TType.I64:
19843 
          self.addressId = iprot.readI64();
19844 
        else:
19845 
          iprot.skip(ftype)
19846 
      else:
19847 
        iprot.skip(ftype)
19848 
      iprot.readFieldEnd()
19849 
    iprot.readStructEnd()
19850 
 
19851 
  def write(self, oprot):
19852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19854 
      return
19855 
    oprot.writeStructBegin('updateShipmentAddress_args')
19856 
    if self.orderId is not None:
19857 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19858 
      oprot.writeI64(self.orderId)
19859 
      oprot.writeFieldEnd()
19860 
    if self.addressId is not None:
19861 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
19862 
      oprot.writeI64(self.addressId)
19863 
      oprot.writeFieldEnd()
19864 
    oprot.writeFieldStop()
19865 
    oprot.writeStructEnd()
19866 
 
19867 
  def validate(self):
19868 
    return
19869 
 
19870 
 
19871 
  def __repr__(self):
19872 
    L = ['%s=%r' % (key, value)
19873 
      for key, value in self.__dict__.iteritems()]
19874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19875 
 
19876 
  def __eq__(self, other):
19877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19878 
 
19879 
  def __ne__(self, other):
19880 
    return not (self == other)
19881 
 
19882 
class updateShipmentAddress_result:
19883 
  """
19884 
  Attributes:
19885 
   - ex
19886 
  """
19887 
 
19888 
  thrift_spec = (
19889 
    None, # 0
19890 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19891 
  )
19892 
 
19893 
  def __init__(self, ex=None,):
19894 
    self.ex = ex
19895 
 
19896 
  def read(self, iprot):
19897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19899 
      return
19900 
    iprot.readStructBegin()
19901 
    while True:
19902 
      (fname, ftype, fid) = iprot.readFieldBegin()
19903 
      if ftype == TType.STOP:
19904 
        break
19905 
      if fid == 1:
19906 
        if ftype == TType.STRUCT:
19907 
          self.ex = TransactionServiceException()
19908 
          self.ex.read(iprot)
19909 
        else:
19910 
          iprot.skip(ftype)
19911 
      else:
19912 
        iprot.skip(ftype)
19913 
      iprot.readFieldEnd()
19914 
    iprot.readStructEnd()
19915 
 
19916 
  def write(self, oprot):
19917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19919 
      return
19920 
    oprot.writeStructBegin('updateShipmentAddress_result')
19921 
    if self.ex is not None:
19922 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19923 
      self.ex.write(oprot)
19924 
      oprot.writeFieldEnd()
19925 
    oprot.writeFieldStop()
19926 
    oprot.writeStructEnd()
19927 
 
19928 
  def validate(self):
19929 
    return
19930 
 
19931 
 
19932 
  def __repr__(self):
19933 
    L = ['%s=%r' % (key, value)
19934 
      for key, value in self.__dict__.iteritems()]
19935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19936 
 
19937 
  def __eq__(self, other):
19938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19939 
 
19940 
  def __ne__(self, other):
19941 
    return not (self == other)
19942 
 
4285 rajveer 19943 
class acceptOrdersForItemId_args:
19944 
  """
19945 
  Attributes:
19946 
   - itemId
19947 
   - inventory
19948 
  """
19949 
 
19950 
  thrift_spec = (
19951 
    None, # 0
19952 
    (1, TType.I64, 'itemId', None, None, ), # 1
19953 
    (2, TType.I64, 'inventory', None, None, ), # 2
19954 
  )
19955 
 
19956 
  def __init__(self, itemId=None, inventory=None,):
19957 
    self.itemId = itemId
19958 
    self.inventory = inventory
19959 
 
19960 
  def read(self, iprot):
19961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19963 
      return
19964 
    iprot.readStructBegin()
19965 
    while True:
19966 
      (fname, ftype, fid) = iprot.readFieldBegin()
19967 
      if ftype == TType.STOP:
19968 
        break
19969 
      if fid == 1:
19970 
        if ftype == TType.I64:
19971 
          self.itemId = iprot.readI64();
19972 
        else:
19973 
          iprot.skip(ftype)
19974 
      elif fid == 2:
19975 
        if ftype == TType.I64:
19976 
          self.inventory = iprot.readI64();
19977 
        else:
19978 
          iprot.skip(ftype)
19979 
      else:
19980 
        iprot.skip(ftype)
19981 
      iprot.readFieldEnd()
19982 
    iprot.readStructEnd()
19983 
 
19984 
  def write(self, oprot):
19985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19987 
      return
19988 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
19989 
    if self.itemId is not None:
19990 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19991 
      oprot.writeI64(self.itemId)
19992 
      oprot.writeFieldEnd()
19993 
    if self.inventory is not None:
19994 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
19995 
      oprot.writeI64(self.inventory)
19996 
      oprot.writeFieldEnd()
19997 
    oprot.writeFieldStop()
19998 
    oprot.writeStructEnd()
19999 
 
20000 
  def validate(self):
20001 
    return
20002 
 
20003 
 
20004 
  def __repr__(self):
20005 
    L = ['%s=%r' % (key, value)
20006 
      for key, value in self.__dict__.iteritems()]
20007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20008 
 
20009 
  def __eq__(self, other):
20010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20011 
 
20012 
  def __ne__(self, other):
20013 
    return not (self == other)
20014 
 
20015 
class acceptOrdersForItemId_result:
20016 
  """
20017 
  Attributes:
20018 
   - success
20019 
   - ex
20020 
  """
20021 
 
20022 
  thrift_spec = (
20023 
    (0, TType.BOOL, 'success', None, None, ), # 0
20024 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20025 
  )
20026 
 
20027 
  def __init__(self, success=None, ex=None,):
20028 
    self.success = success
20029 
    self.ex = ex
20030 
 
20031 
  def read(self, iprot):
20032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20034 
      return
20035 
    iprot.readStructBegin()
20036 
    while True:
20037 
      (fname, ftype, fid) = iprot.readFieldBegin()
20038 
      if ftype == TType.STOP:
20039 
        break
20040 
      if fid == 0:
20041 
        if ftype == TType.BOOL:
20042 
          self.success = iprot.readBool();
20043 
        else:
20044 
          iprot.skip(ftype)
20045 
      elif fid == 1:
20046 
        if ftype == TType.STRUCT:
20047 
          self.ex = TransactionServiceException()
20048 
          self.ex.read(iprot)
20049 
        else:
20050 
          iprot.skip(ftype)
20051 
      else:
20052 
        iprot.skip(ftype)
20053 
      iprot.readFieldEnd()
20054 
    iprot.readStructEnd()
20055 
 
20056 
  def write(self, oprot):
20057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20059 
      return
20060 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
20061 
    if self.success is not None:
20062 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20063 
      oprot.writeBool(self.success)
20064 
      oprot.writeFieldEnd()
20065 
    if self.ex is not None:
20066 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20067 
      self.ex.write(oprot)
20068 
      oprot.writeFieldEnd()
20069 
    oprot.writeFieldStop()
20070 
    oprot.writeStructEnd()
20071 
 
20072 
  def validate(self):
20073 
    return
20074 
 
20075 
 
20076 
  def __repr__(self):
20077 
    L = ['%s=%r' % (key, value)
20078 
      for key, value in self.__dict__.iteritems()]
20079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20080 
 
20081 
  def __eq__(self, other):
20082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20083 
 
20084 
  def __ne__(self, other):
20085 
    return not (self == other)
4303 rajveer 20086 
 
20087 
class markOrdersAsPORaised_args:
20088 
  """
20089 
  Attributes:
20090 
   - vendorId
20091 
   - itemId
20092 
   - quantity
20093 
   - estimate
4369 rajveer 20094 
   - isReminder
4303 rajveer 20095 
  """
20096 
 
20097 
  thrift_spec = (
20098 
    None, # 0
20099 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20100 
    (2, TType.I64, 'itemId', None, None, ), # 2
20101 
    (3, TType.I64, 'quantity', None, None, ), # 3
20102 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20103 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20104 
  )
20105 
 
4369 rajveer 20106 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20107 
    self.vendorId = vendorId
20108 
    self.itemId = itemId
20109 
    self.quantity = quantity
20110 
    self.estimate = estimate
4369 rajveer 20111 
    self.isReminder = isReminder
4303 rajveer 20112 
 
20113 
  def read(self, iprot):
20114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20116 
      return
20117 
    iprot.readStructBegin()
20118 
    while True:
20119 
      (fname, ftype, fid) = iprot.readFieldBegin()
20120 
      if ftype == TType.STOP:
20121 
        break
20122 
      if fid == 1:
20123 
        if ftype == TType.I64:
20124 
          self.vendorId = iprot.readI64();
20125 
        else:
20126 
          iprot.skip(ftype)
20127 
      elif fid == 2:
20128 
        if ftype == TType.I64:
20129 
          self.itemId = iprot.readI64();
20130 
        else:
20131 
          iprot.skip(ftype)
20132 
      elif fid == 3:
20133 
        if ftype == TType.I64:
20134 
          self.quantity = iprot.readI64();
20135 
        else:
20136 
          iprot.skip(ftype)
20137 
      elif fid == 4:
20138 
        if ftype == TType.I64:
20139 
          self.estimate = iprot.readI64();
20140 
        else:
20141 
          iprot.skip(ftype)
4369 rajveer 20142 
      elif fid == 5:
20143 
        if ftype == TType.BOOL:
20144 
          self.isReminder = iprot.readBool();
20145 
        else:
20146 
          iprot.skip(ftype)
4303 rajveer 20147 
      else:
20148 
        iprot.skip(ftype)
20149 
      iprot.readFieldEnd()
20150 
    iprot.readStructEnd()
20151 
 
20152 
  def write(self, oprot):
20153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20155 
      return
20156 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
20157 
    if self.vendorId is not None:
20158 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20159 
      oprot.writeI64(self.vendorId)
20160 
      oprot.writeFieldEnd()
20161 
    if self.itemId is not None:
20162 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20163 
      oprot.writeI64(self.itemId)
20164 
      oprot.writeFieldEnd()
20165 
    if self.quantity is not None:
20166 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20167 
      oprot.writeI64(self.quantity)
20168 
      oprot.writeFieldEnd()
20169 
    if self.estimate is not None:
20170 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20171 
      oprot.writeI64(self.estimate)
20172 
      oprot.writeFieldEnd()
4369 rajveer 20173 
    if self.isReminder is not None:
20174 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20175 
      oprot.writeBool(self.isReminder)
20176 
      oprot.writeFieldEnd()
4303 rajveer 20177 
    oprot.writeFieldStop()
20178 
    oprot.writeStructEnd()
20179 
 
20180 
  def validate(self):
20181 
    return
20182 
 
20183 
 
20184 
  def __repr__(self):
20185 
    L = ['%s=%r' % (key, value)
20186 
      for key, value in self.__dict__.iteritems()]
20187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20188 
 
20189 
  def __eq__(self, other):
20190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20191 
 
20192 
  def __ne__(self, other):
20193 
    return not (self == other)
20194 
 
20195 
class markOrdersAsPORaised_result:
20196 
  """
20197 
  Attributes:
20198 
   - ex
20199 
  """
20200 
 
20201 
  thrift_spec = (
20202 
    None, # 0
20203 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20204 
  )
20205 
 
20206 
  def __init__(self, ex=None,):
20207 
    self.ex = ex
20208 
 
20209 
  def read(self, iprot):
20210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20212 
      return
20213 
    iprot.readStructBegin()
20214 
    while True:
20215 
      (fname, ftype, fid) = iprot.readFieldBegin()
20216 
      if ftype == TType.STOP:
20217 
        break
20218 
      if fid == 1:
20219 
        if ftype == TType.STRUCT:
20220 
          self.ex = TransactionServiceException()
20221 
          self.ex.read(iprot)
20222 
        else:
20223 
          iprot.skip(ftype)
20224 
      else:
20225 
        iprot.skip(ftype)
20226 
      iprot.readFieldEnd()
20227 
    iprot.readStructEnd()
20228 
 
20229 
  def write(self, oprot):
20230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20232 
      return
20233 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
20234 
    if self.ex is not None:
20235 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20236 
      self.ex.write(oprot)
20237 
      oprot.writeFieldEnd()
20238 
    oprot.writeFieldStop()
20239 
    oprot.writeStructEnd()
20240 
 
20241 
  def validate(self):
20242 
    return
20243 
 
20244 
 
20245 
  def __repr__(self):
20246 
    L = ['%s=%r' % (key, value)
20247 
      for key, value in self.__dict__.iteritems()]
20248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20249 
 
20250 
  def __eq__(self, other):
20251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20252 
 
20253 
  def __ne__(self, other):
20254 
    return not (self == other)
20255 
 
20256 
class markOrdersAsReversalInitiated_args:
20257 
  """
20258 
  Attributes:
20259 
   - vendorId
20260 
   - itemId
20261 
   - quantity
20262 
   - estimate
4369 rajveer 20263 
   - isReminder
4303 rajveer 20264 
  """
20265 
 
20266 
  thrift_spec = (
20267 
    None, # 0
20268 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20269 
    (2, TType.I64, 'itemId', None, None, ), # 2
20270 
    (3, TType.I64, 'quantity', None, None, ), # 3
20271 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20272 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20273 
  )
20274 
 
4369 rajveer 20275 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20276 
    self.vendorId = vendorId
20277 
    self.itemId = itemId
20278 
    self.quantity = quantity
20279 
    self.estimate = estimate
4369 rajveer 20280 
    self.isReminder = isReminder
4303 rajveer 20281 
 
20282 
  def read(self, iprot):
20283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20285 
      return
20286 
    iprot.readStructBegin()
20287 
    while True:
20288 
      (fname, ftype, fid) = iprot.readFieldBegin()
20289 
      if ftype == TType.STOP:
20290 
        break
20291 
      if fid == 1:
20292 
        if ftype == TType.I64:
20293 
          self.vendorId = iprot.readI64();
20294 
        else:
20295 
          iprot.skip(ftype)
20296 
      elif fid == 2:
20297 
        if ftype == TType.I64:
20298 
          self.itemId = iprot.readI64();
20299 
        else:
20300 
          iprot.skip(ftype)
20301 
      elif fid == 3:
20302 
        if ftype == TType.I64:
20303 
          self.quantity = iprot.readI64();
20304 
        else:
20305 
          iprot.skip(ftype)
20306 
      elif fid == 4:
20307 
        if ftype == TType.I64:
20308 
          self.estimate = iprot.readI64();
20309 
        else:
20310 
          iprot.skip(ftype)
4369 rajveer 20311 
      elif fid == 5:
20312 
        if ftype == TType.BOOL:
20313 
          self.isReminder = iprot.readBool();
20314 
        else:
20315 
          iprot.skip(ftype)
4303 rajveer 20316 
      else:
20317 
        iprot.skip(ftype)
20318 
      iprot.readFieldEnd()
20319 
    iprot.readStructEnd()
20320 
 
20321 
  def write(self, oprot):
20322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20324 
      return
20325 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
20326 
    if self.vendorId is not None:
20327 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20328 
      oprot.writeI64(self.vendorId)
20329 
      oprot.writeFieldEnd()
20330 
    if self.itemId is not None:
20331 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20332 
      oprot.writeI64(self.itemId)
20333 
      oprot.writeFieldEnd()
20334 
    if self.quantity is not None:
20335 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20336 
      oprot.writeI64(self.quantity)
20337 
      oprot.writeFieldEnd()
20338 
    if self.estimate is not None:
20339 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20340 
      oprot.writeI64(self.estimate)
20341 
      oprot.writeFieldEnd()
4369 rajveer 20342 
    if self.isReminder is not None:
20343 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20344 
      oprot.writeBool(self.isReminder)
20345 
      oprot.writeFieldEnd()
4303 rajveer 20346 
    oprot.writeFieldStop()
20347 
    oprot.writeStructEnd()
20348 
 
20349 
  def validate(self):
20350 
    return
20351 
 
20352 
 
20353 
  def __repr__(self):
20354 
    L = ['%s=%r' % (key, value)
20355 
      for key, value in self.__dict__.iteritems()]
20356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20357 
 
20358 
  def __eq__(self, other):
20359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20360 
 
20361 
  def __ne__(self, other):
20362 
    return not (self == other)
20363 
 
20364 
class markOrdersAsReversalInitiated_result:
20365 
  """
20366 
  Attributes:
20367 
   - ex
20368 
  """
20369 
 
20370 
  thrift_spec = (
20371 
    None, # 0
20372 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20373 
  )
20374 
 
20375 
  def __init__(self, ex=None,):
20376 
    self.ex = ex
20377 
 
20378 
  def read(self, iprot):
20379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20381 
      return
20382 
    iprot.readStructBegin()
20383 
    while True:
20384 
      (fname, ftype, fid) = iprot.readFieldBegin()
20385 
      if ftype == TType.STOP:
20386 
        break
20387 
      if fid == 1:
20388 
        if ftype == TType.STRUCT:
20389 
          self.ex = TransactionServiceException()
20390 
          self.ex.read(iprot)
20391 
        else:
20392 
          iprot.skip(ftype)
20393 
      else:
20394 
        iprot.skip(ftype)
20395 
      iprot.readFieldEnd()
20396 
    iprot.readStructEnd()
20397 
 
20398 
  def write(self, oprot):
20399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20401 
      return
20402 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
20403 
    if self.ex is not None:
20404 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20405 
      self.ex.write(oprot)
20406 
      oprot.writeFieldEnd()
20407 
    oprot.writeFieldStop()
20408 
    oprot.writeStructEnd()
20409 
 
20410 
  def validate(self):
20411 
    return
20412 
 
20413 
 
20414 
  def __repr__(self):
20415 
    L = ['%s=%r' % (key, value)
20416 
      for key, value in self.__dict__.iteritems()]
20417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20418 
 
20419 
  def __eq__(self, other):
20420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20421 
 
20422 
  def __ne__(self, other):
20423 
    return not (self == other)
20424 
 
20425 
class markOrdersAsNotAvailabke_args:
20426 
  """
20427 
  Attributes:
20428 
   - vendorId
20429 
   - itemId
20430 
   - quantity
20431 
   - estimate
4369 rajveer 20432 
   - isReminder
4303 rajveer 20433 
  """
20434 
 
20435 
  thrift_spec = (
20436 
    None, # 0
20437 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20438 
    (2, TType.I64, 'itemId', None, None, ), # 2
20439 
    (3, TType.I64, 'quantity', None, None, ), # 3
20440 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20441 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20442 
  )
20443 
 
4369 rajveer 20444 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20445 
    self.vendorId = vendorId
20446 
    self.itemId = itemId
20447 
    self.quantity = quantity
20448 
    self.estimate = estimate
4369 rajveer 20449 
    self.isReminder = isReminder
4303 rajveer 20450 
 
20451 
  def read(self, iprot):
20452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20454 
      return
20455 
    iprot.readStructBegin()
20456 
    while True:
20457 
      (fname, ftype, fid) = iprot.readFieldBegin()
20458 
      if ftype == TType.STOP:
20459 
        break
20460 
      if fid == 1:
20461 
        if ftype == TType.I64:
20462 
          self.vendorId = iprot.readI64();
20463 
        else:
20464 
          iprot.skip(ftype)
20465 
      elif fid == 2:
20466 
        if ftype == TType.I64:
20467 
          self.itemId = iprot.readI64();
20468 
        else:
20469 
          iprot.skip(ftype)
20470 
      elif fid == 3:
20471 
        if ftype == TType.I64:
20472 
          self.quantity = iprot.readI64();
20473 
        else:
20474 
          iprot.skip(ftype)
20475 
      elif fid == 4:
20476 
        if ftype == TType.I64:
20477 
          self.estimate = iprot.readI64();
20478 
        else:
20479 
          iprot.skip(ftype)
4369 rajveer 20480 
      elif fid == 5:
20481 
        if ftype == TType.BOOL:
20482 
          self.isReminder = iprot.readBool();
20483 
        else:
20484 
          iprot.skip(ftype)
4303 rajveer 20485 
      else:
20486 
        iprot.skip(ftype)
20487 
      iprot.readFieldEnd()
20488 
    iprot.readStructEnd()
20489 
 
20490 
  def write(self, oprot):
20491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20493 
      return
20494 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
20495 
    if self.vendorId is not None:
20496 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20497 
      oprot.writeI64(self.vendorId)
20498 
      oprot.writeFieldEnd()
20499 
    if self.itemId is not None:
20500 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20501 
      oprot.writeI64(self.itemId)
20502 
      oprot.writeFieldEnd()
20503 
    if self.quantity is not None:
20504 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20505 
      oprot.writeI64(self.quantity)
20506 
      oprot.writeFieldEnd()
20507 
    if self.estimate is not None:
20508 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20509 
      oprot.writeI64(self.estimate)
20510 
      oprot.writeFieldEnd()
4369 rajveer 20511 
    if self.isReminder is not None:
20512 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20513 
      oprot.writeBool(self.isReminder)
20514 
      oprot.writeFieldEnd()
4303 rajveer 20515 
    oprot.writeFieldStop()
20516 
    oprot.writeStructEnd()
20517 
 
20518 
  def validate(self):
20519 
    return
20520 
 
20521 
 
20522 
  def __repr__(self):
20523 
    L = ['%s=%r' % (key, value)
20524 
      for key, value in self.__dict__.iteritems()]
20525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20526 
 
20527 
  def __eq__(self, other):
20528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20529 
 
20530 
  def __ne__(self, other):
20531 
    return not (self == other)
20532 
 
20533 
class markOrdersAsNotAvailabke_result:
20534 
  """
20535 
  Attributes:
20536 
   - ex
20537 
  """
20538 
 
20539 
  thrift_spec = (
20540 
    None, # 0
20541 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20542 
  )
20543 
 
20544 
  def __init__(self, ex=None,):
20545 
    self.ex = ex
20546 
 
20547 
  def read(self, iprot):
20548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20550 
      return
20551 
    iprot.readStructBegin()
20552 
    while True:
20553 
      (fname, ftype, fid) = iprot.readFieldBegin()
20554 
      if ftype == TType.STOP:
20555 
        break
20556 
      if fid == 1:
20557 
        if ftype == TType.STRUCT:
20558 
          self.ex = TransactionServiceException()
20559 
          self.ex.read(iprot)
20560 
        else:
20561 
          iprot.skip(ftype)
20562 
      else:
20563 
        iprot.skip(ftype)
20564 
      iprot.readFieldEnd()
20565 
    iprot.readStructEnd()
20566 
 
20567 
  def write(self, oprot):
20568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20570 
      return
20571 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
20572 
    if self.ex is not None:
20573 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20574 
      self.ex.write(oprot)
20575 
      oprot.writeFieldEnd()
20576 
    oprot.writeFieldStop()
20577 
    oprot.writeStructEnd()
20578 
 
20579 
  def validate(self):
20580 
    return
20581 
 
20582 
 
20583 
  def __repr__(self):
20584 
    L = ['%s=%r' % (key, value)
20585 
      for key, value in self.__dict__.iteritems()]
20586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20587 
 
20588 
  def __eq__(self, other):
20589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20590 
 
20591 
  def __ne__(self, other):
20592 
    return not (self == other)
4369 rajveer 20593 
 
20594 
class markOrdersAsTimeout_args:
20595 
  """
20596 
  Attributes:
20597 
   - vendorId
20598 
  """
20599 
 
20600 
  thrift_spec = (
20601 
    None, # 0
20602 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20603 
  )
20604 
 
20605 
  def __init__(self, vendorId=None,):
20606 
    self.vendorId = vendorId
20607 
 
20608 
  def read(self, iprot):
20609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20611 
      return
20612 
    iprot.readStructBegin()
20613 
    while True:
20614 
      (fname, ftype, fid) = iprot.readFieldBegin()
20615 
      if ftype == TType.STOP:
20616 
        break
20617 
      if fid == 1:
20618 
        if ftype == TType.I64:
20619 
          self.vendorId = iprot.readI64();
20620 
        else:
20621 
          iprot.skip(ftype)
20622 
      else:
20623 
        iprot.skip(ftype)
20624 
      iprot.readFieldEnd()
20625 
    iprot.readStructEnd()
20626 
 
20627 
  def write(self, oprot):
20628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20630 
      return
20631 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
20632 
    if self.vendorId is not None:
20633 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20634 
      oprot.writeI64(self.vendorId)
20635 
      oprot.writeFieldEnd()
20636 
    oprot.writeFieldStop()
20637 
    oprot.writeStructEnd()
20638 
 
20639 
  def validate(self):
20640 
    return
20641 
 
20642 
 
20643 
  def __repr__(self):
20644 
    L = ['%s=%r' % (key, value)
20645 
      for key, value in self.__dict__.iteritems()]
20646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20647 
 
20648 
  def __eq__(self, other):
20649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20650 
 
20651 
  def __ne__(self, other):
20652 
    return not (self == other)
20653 
 
20654 
class markOrdersAsTimeout_result:
20655 
  """
20656 
  Attributes:
20657 
   - success
20658 
   - ex
20659 
  """
20660 
 
20661 
  thrift_spec = (
20662 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
20663 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20664 
  )
20665 
 
20666 
  def __init__(self, success=None, ex=None,):
20667 
    self.success = success
20668 
    self.ex = ex
20669 
 
20670 
  def read(self, iprot):
20671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20673 
      return
20674 
    iprot.readStructBegin()
20675 
    while True:
20676 
      (fname, ftype, fid) = iprot.readFieldBegin()
20677 
      if ftype == TType.STOP:
20678 
        break
20679 
      if fid == 0:
20680 
        if ftype == TType.MAP:
20681 
          self.success = {}
5713 rajveer 20682 
          (_ktype459, _vtype460, _size458 ) = iprot.readMapBegin()
20683 
          for _i462 in xrange(_size458):
20684 
            _key463 = iprot.readI32();
20685 
            _val464 = TimeoutSummary()
20686 
            _val464.read(iprot)
20687 
            self.success[_key463] = _val464
4369 rajveer 20688 
          iprot.readMapEnd()
20689 
        else:
20690 
          iprot.skip(ftype)
20691 
      elif fid == 1:
20692 
        if ftype == TType.STRUCT:
20693 
          self.ex = TransactionServiceException()
20694 
          self.ex.read(iprot)
20695 
        else:
20696 
          iprot.skip(ftype)
20697 
      else:
20698 
        iprot.skip(ftype)
20699 
      iprot.readFieldEnd()
20700 
    iprot.readStructEnd()
20701 
 
20702 
  def write(self, oprot):
20703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20705 
      return
20706 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
20707 
    if self.success is not None:
20708 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20709 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5713 rajveer 20710 
      for kiter465,viter466 in self.success.items():
20711 
        oprot.writeI32(kiter465)
20712 
        viter466.write(oprot)
4369 rajveer 20713 
      oprot.writeMapEnd()
20714 
      oprot.writeFieldEnd()
20715 
    if self.ex is not None:
20716 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20717 
      self.ex.write(oprot)
20718 
      oprot.writeFieldEnd()
20719 
    oprot.writeFieldStop()
20720 
    oprot.writeStructEnd()
20721 
 
20722 
  def validate(self):
20723 
    return
20724 
 
20725 
 
20726 
  def __repr__(self):
20727 
    L = ['%s=%r' % (key, value)
20728 
      for key, value in self.__dict__.iteritems()]
20729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20730 
 
20731 
  def __eq__(self, other):
20732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20733 
 
20734 
  def __ne__(self, other):
20735 
    return not (self == other)
4386 anupam.sin 20736 
 
4662 rajveer 20737 
class markOrderAsLostInTransit_args:
20738 
  """
20739 
  Attributes:
20740 
   - orderId
20741 
  """
20742 
 
20743 
  thrift_spec = (
20744 
    None, # 0
20745 
    (1, TType.I64, 'orderId', None, None, ), # 1
20746 
  )
20747 
 
20748 
  def __init__(self, orderId=None,):
20749 
    self.orderId = orderId
20750 
 
20751 
  def read(self, iprot):
20752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20754 
      return
20755 
    iprot.readStructBegin()
20756 
    while True:
20757 
      (fname, ftype, fid) = iprot.readFieldBegin()
20758 
      if ftype == TType.STOP:
20759 
        break
20760 
      if fid == 1:
20761 
        if ftype == TType.I64:
20762 
          self.orderId = iprot.readI64();
20763 
        else:
20764 
          iprot.skip(ftype)
20765 
      else:
20766 
        iprot.skip(ftype)
20767 
      iprot.readFieldEnd()
20768 
    iprot.readStructEnd()
20769 
 
20770 
  def write(self, oprot):
20771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20773 
      return
20774 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
20775 
    if self.orderId is not None:
20776 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20777 
      oprot.writeI64(self.orderId)
20778 
      oprot.writeFieldEnd()
20779 
    oprot.writeFieldStop()
20780 
    oprot.writeStructEnd()
20781 
 
20782 
  def validate(self):
20783 
    return
20784 
 
20785 
 
20786 
  def __repr__(self):
20787 
    L = ['%s=%r' % (key, value)
20788 
      for key, value in self.__dict__.iteritems()]
20789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20790 
 
20791 
  def __eq__(self, other):
20792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20793 
 
20794 
  def __ne__(self, other):
20795 
    return not (self == other)
20796 
 
20797 
class markOrderAsLostInTransit_result:
20798 
  """
20799 
  Attributes:
20800 
   - success
20801 
   - ex
20802 
  """
20803 
 
20804 
  thrift_spec = (
20805 
    (0, TType.BOOL, 'success', None, None, ), # 0
20806 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20807 
  )
20808 
 
20809 
  def __init__(self, success=None, ex=None,):
20810 
    self.success = success
20811 
    self.ex = ex
20812 
 
20813 
  def read(self, iprot):
20814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20816 
      return
20817 
    iprot.readStructBegin()
20818 
    while True:
20819 
      (fname, ftype, fid) = iprot.readFieldBegin()
20820 
      if ftype == TType.STOP:
20821 
        break
20822 
      if fid == 0:
20823 
        if ftype == TType.BOOL:
20824 
          self.success = iprot.readBool();
20825 
        else:
20826 
          iprot.skip(ftype)
20827 
      elif fid == 1:
20828 
        if ftype == TType.STRUCT:
20829 
          self.ex = TransactionServiceException()
20830 
          self.ex.read(iprot)
20831 
        else:
20832 
          iprot.skip(ftype)
20833 
      else:
20834 
        iprot.skip(ftype)
20835 
      iprot.readFieldEnd()
20836 
    iprot.readStructEnd()
20837 
 
20838 
  def write(self, oprot):
20839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20841 
      return
20842 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
20843 
    if self.success is not None:
20844 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20845 
      oprot.writeBool(self.success)
20846 
      oprot.writeFieldEnd()
20847 
    if self.ex is not None:
20848 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20849 
      self.ex.write(oprot)
20850 
      oprot.writeFieldEnd()
20851 
    oprot.writeFieldStop()
20852 
    oprot.writeStructEnd()
20853 
 
20854 
  def validate(self):
20855 
    return
20856 
 
20857 
 
20858 
  def __repr__(self):
20859 
    L = ['%s=%r' % (key, value)
20860 
      for key, value in self.__dict__.iteritems()]
20861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20862 
 
20863 
  def __eq__(self, other):
20864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20865 
 
20866 
  def __ne__(self, other):
20867 
    return not (self == other)
20868 
 
4386 anupam.sin 20869 
class getOrderForAwb_args:
20870 
  """
20871 
  Attributes:
20872 
   - awb
20873 
  """
20874 
 
20875 
  thrift_spec = (
20876 
    None, # 0
20877 
    (1, TType.STRING, 'awb', None, None, ), # 1
20878 
  )
20879 
 
20880 
  def __init__(self, awb=None,):
20881 
    self.awb = awb
20882 
 
20883 
  def read(self, iprot):
20884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20886 
      return
20887 
    iprot.readStructBegin()
20888 
    while True:
20889 
      (fname, ftype, fid) = iprot.readFieldBegin()
20890 
      if ftype == TType.STOP:
20891 
        break
20892 
      if fid == 1:
20893 
        if ftype == TType.STRING:
20894 
          self.awb = iprot.readString();
20895 
        else:
20896 
          iprot.skip(ftype)
20897 
      else:
20898 
        iprot.skip(ftype)
20899 
      iprot.readFieldEnd()
20900 
    iprot.readStructEnd()
20901 
 
20902 
  def write(self, oprot):
20903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20905 
      return
20906 
    oprot.writeStructBegin('getOrderForAwb_args')
20907 
    if self.awb is not None:
20908 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
20909 
      oprot.writeString(self.awb)
20910 
      oprot.writeFieldEnd()
20911 
    oprot.writeFieldStop()
20912 
    oprot.writeStructEnd()
20913 
 
20914 
  def validate(self):
20915 
    return
20916 
 
20917 
 
20918 
  def __repr__(self):
20919 
    L = ['%s=%r' % (key, value)
20920 
      for key, value in self.__dict__.iteritems()]
20921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20922 
 
20923 
  def __eq__(self, other):
20924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20925 
 
20926 
  def __ne__(self, other):
20927 
    return not (self == other)
20928 
 
20929 
class getOrderForAwb_result:
20930 
  """
20931 
  Attributes:
20932 
   - success
20933 
   - ex
20934 
  """
20935 
 
20936 
  thrift_spec = (
20937 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20938 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20939 
  )
20940 
 
20941 
  def __init__(self, success=None, ex=None,):
20942 
    self.success = success
20943 
    self.ex = ex
20944 
 
20945 
  def read(self, iprot):
20946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20948 
      return
20949 
    iprot.readStructBegin()
20950 
    while True:
20951 
      (fname, ftype, fid) = iprot.readFieldBegin()
20952 
      if ftype == TType.STOP:
20953 
        break
20954 
      if fid == 0:
20955 
        if ftype == TType.STRUCT:
20956 
          self.success = Order()
20957 
          self.success.read(iprot)
20958 
        else:
20959 
          iprot.skip(ftype)
20960 
      elif fid == 1:
20961 
        if ftype == TType.STRUCT:
20962 
          self.ex = TransactionServiceException()
20963 
          self.ex.read(iprot)
20964 
        else:
20965 
          iprot.skip(ftype)
20966 
      else:
20967 
        iprot.skip(ftype)
20968 
      iprot.readFieldEnd()
20969 
    iprot.readStructEnd()
20970 
 
20971 
  def write(self, oprot):
20972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20974 
      return
20975 
    oprot.writeStructBegin('getOrderForAwb_result')
20976 
    if self.success is not None:
20977 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20978 
      self.success.write(oprot)
20979 
      oprot.writeFieldEnd()
20980 
    if self.ex is not None:
20981 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20982 
      self.ex.write(oprot)
20983 
      oprot.writeFieldEnd()
20984 
    oprot.writeFieldStop()
20985 
    oprot.writeStructEnd()
20986 
 
20987 
  def validate(self):
20988 
    return
20989 
 
20990 
 
20991 
  def __repr__(self):
20992 
    L = ['%s=%r' % (key, value)
20993 
      for key, value in self.__dict__.iteritems()]
20994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20995 
 
20996 
  def __eq__(self, other):
20997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20998 
 
20999 
  def __ne__(self, other):
21000 
    return not (self == other)
4506 phani.kuma 21001 
 
21002 
class getOrdersForProviderForStatus_args:
21003 
  """
21004 
  Attributes:
21005 
   - logistics_provider_id
4910 phani.kuma 21006 
   - order_status_list
4506 phani.kuma 21007 
  """
21008 
 
21009 
  thrift_spec = (
21010 
    None, # 0
21011 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 21012 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 21013 
  )
21014 
 
4910 phani.kuma 21015 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 21016 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 21017 
    self.order_status_list = order_status_list
4506 phani.kuma 21018 
 
21019 
  def read(self, iprot):
21020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21022 
      return
21023 
    iprot.readStructBegin()
21024 
    while True:
21025 
      (fname, ftype, fid) = iprot.readFieldBegin()
21026 
      if ftype == TType.STOP:
21027 
        break
21028 
      if fid == 1:
21029 
        if ftype == TType.I64:
21030 
          self.logistics_provider_id = iprot.readI64();
21031 
        else:
21032 
          iprot.skip(ftype)
21033 
      elif fid == 2:
4910 phani.kuma 21034 
        if ftype == TType.LIST:
21035 
          self.order_status_list = []
5713 rajveer 21036 
          (_etype470, _size467) = iprot.readListBegin()
21037 
          for _i471 in xrange(_size467):
21038 
            _elem472 = iprot.readI32();
21039 
            self.order_status_list.append(_elem472)
4910 phani.kuma 21040 
          iprot.readListEnd()
4506 phani.kuma 21041 
        else:
21042 
          iprot.skip(ftype)
21043 
      else:
21044 
        iprot.skip(ftype)
21045 
      iprot.readFieldEnd()
21046 
    iprot.readStructEnd()
21047 
 
21048 
  def write(self, oprot):
21049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21051 
      return
21052 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
21053 
    if self.logistics_provider_id is not None:
21054 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
21055 
      oprot.writeI64(self.logistics_provider_id)
21056 
      oprot.writeFieldEnd()
4910 phani.kuma 21057 
    if self.order_status_list is not None:
21058 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
21059 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5713 rajveer 21060 
      for iter473 in self.order_status_list:
21061 
        oprot.writeI32(iter473)
4910 phani.kuma 21062 
      oprot.writeListEnd()
4506 phani.kuma 21063 
      oprot.writeFieldEnd()
21064 
    oprot.writeFieldStop()
21065 
    oprot.writeStructEnd()
21066 
 
21067 
  def validate(self):
21068 
    return
21069 
 
21070 
 
21071 
  def __repr__(self):
21072 
    L = ['%s=%r' % (key, value)
21073 
      for key, value in self.__dict__.iteritems()]
21074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21075 
 
21076 
  def __eq__(self, other):
21077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21078 
 
21079 
  def __ne__(self, other):
21080 
    return not (self == other)
21081 
 
21082 
class getOrdersForProviderForStatus_result:
21083 
  """
21084 
  Attributes:
21085 
   - success
21086 
   - ex
21087 
  """
21088 
 
21089 
  thrift_spec = (
21090 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21091 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21092 
  )
21093 
 
21094 
  def __init__(self, success=None, ex=None,):
21095 
    self.success = success
21096 
    self.ex = ex
21097 
 
21098 
  def read(self, iprot):
21099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21101 
      return
21102 
    iprot.readStructBegin()
21103 
    while True:
21104 
      (fname, ftype, fid) = iprot.readFieldBegin()
21105 
      if ftype == TType.STOP:
21106 
        break
21107 
      if fid == 0:
21108 
        if ftype == TType.LIST:
21109 
          self.success = []
5713 rajveer 21110 
          (_etype477, _size474) = iprot.readListBegin()
21111 
          for _i478 in xrange(_size474):
21112 
            _elem479 = Order()
21113 
            _elem479.read(iprot)
21114 
            self.success.append(_elem479)
4506 phani.kuma 21115 
          iprot.readListEnd()
21116 
        else:
21117 
          iprot.skip(ftype)
21118 
      elif fid == 1:
21119 
        if ftype == TType.STRUCT:
21120 
          self.ex = TransactionServiceException()
21121 
          self.ex.read(iprot)
21122 
        else:
21123 
          iprot.skip(ftype)
21124 
      else:
21125 
        iprot.skip(ftype)
21126 
      iprot.readFieldEnd()
21127 
    iprot.readStructEnd()
21128 
 
21129 
  def write(self, oprot):
21130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21132 
      return
21133 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
21134 
    if self.success is not None:
21135 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21136 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 21137 
      for iter480 in self.success:
21138 
        iter480.write(oprot)
4506 phani.kuma 21139 
      oprot.writeListEnd()
21140 
      oprot.writeFieldEnd()
21141 
    if self.ex is not None:
21142 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21143 
      self.ex.write(oprot)
21144 
      oprot.writeFieldEnd()
21145 
    oprot.writeFieldStop()
21146 
    oprot.writeStructEnd()
21147 
 
21148 
  def validate(self):
21149 
    return
21150 
 
21151 
 
21152 
  def __repr__(self):
21153 
    L = ['%s=%r' % (key, value)
21154 
      for key, value in self.__dict__.iteritems()]
21155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21156 
 
21157 
  def __eq__(self, other):
21158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21159 
 
21160 
  def __ne__(self, other):
21161 
    return not (self == other)
4600 varun.gupt 21162 
 
21163 
class getBilledOrdersForVendor_args:
21164 
  """
21165 
  Attributes:
21166 
   - vendorId
21167 
   - billingDateFrom
21168 
   - billingDateTo
21169 
  """
21170 
 
21171 
  thrift_spec = (
21172 
    None, # 0
21173 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21174 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
21175 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
21176 
  )
21177 
 
21178 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
21179 
    self.vendorId = vendorId
21180 
    self.billingDateFrom = billingDateFrom
21181 
    self.billingDateTo = billingDateTo
21182 
 
21183 
  def read(self, iprot):
21184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21186 
      return
21187 
    iprot.readStructBegin()
21188 
    while True:
21189 
      (fname, ftype, fid) = iprot.readFieldBegin()
21190 
      if ftype == TType.STOP:
21191 
        break
21192 
      if fid == 1:
21193 
        if ftype == TType.I64:
21194 
          self.vendorId = iprot.readI64();
21195 
        else:
21196 
          iprot.skip(ftype)
21197 
      elif fid == 2:
21198 
        if ftype == TType.I64:
21199 
          self.billingDateFrom = iprot.readI64();
21200 
        else:
21201 
          iprot.skip(ftype)
21202 
      elif fid == 3:
21203 
        if ftype == TType.I64:
21204 
          self.billingDateTo = iprot.readI64();
21205 
        else:
21206 
          iprot.skip(ftype)
21207 
      else:
21208 
        iprot.skip(ftype)
21209 
      iprot.readFieldEnd()
21210 
    iprot.readStructEnd()
21211 
 
21212 
  def write(self, oprot):
21213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21215 
      return
21216 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
21217 
    if self.vendorId is not None:
21218 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21219 
      oprot.writeI64(self.vendorId)
21220 
      oprot.writeFieldEnd()
21221 
    if self.billingDateFrom is not None:
21222 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
21223 
      oprot.writeI64(self.billingDateFrom)
21224 
      oprot.writeFieldEnd()
21225 
    if self.billingDateTo is not None:
21226 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
21227 
      oprot.writeI64(self.billingDateTo)
21228 
      oprot.writeFieldEnd()
21229 
    oprot.writeFieldStop()
21230 
    oprot.writeStructEnd()
21231 
 
21232 
  def validate(self):
21233 
    return
21234 
 
21235 
 
21236 
  def __repr__(self):
21237 
    L = ['%s=%r' % (key, value)
21238 
      for key, value in self.__dict__.iteritems()]
21239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21240 
 
21241 
  def __eq__(self, other):
21242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21243 
 
21244 
  def __ne__(self, other):
21245 
    return not (self == other)
21246 
 
21247 
class getBilledOrdersForVendor_result:
21248 
  """
21249 
  Attributes:
21250 
   - success
21251 
   - ex
21252 
  """
21253 
 
21254 
  thrift_spec = (
21255 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21256 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21257 
  )
21258 
 
21259 
  def __init__(self, success=None, ex=None,):
21260 
    self.success = success
21261 
    self.ex = ex
21262 
 
21263 
  def read(self, iprot):
21264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21266 
      return
21267 
    iprot.readStructBegin()
21268 
    while True:
21269 
      (fname, ftype, fid) = iprot.readFieldBegin()
21270 
      if ftype == TType.STOP:
21271 
        break
21272 
      if fid == 0:
21273 
        if ftype == TType.LIST:
21274 
          self.success = []
5713 rajveer 21275 
          (_etype484, _size481) = iprot.readListBegin()
21276 
          for _i485 in xrange(_size481):
21277 
            _elem486 = Order()
21278 
            _elem486.read(iprot)
21279 
            self.success.append(_elem486)
4600 varun.gupt 21280 
          iprot.readListEnd()
21281 
        else:
21282 
          iprot.skip(ftype)
21283 
      elif fid == 1:
21284 
        if ftype == TType.STRUCT:
21285 
          self.ex = TransactionServiceException()
21286 
          self.ex.read(iprot)
21287 
        else:
21288 
          iprot.skip(ftype)
21289 
      else:
21290 
        iprot.skip(ftype)
21291 
      iprot.readFieldEnd()
21292 
    iprot.readStructEnd()
21293 
 
21294 
  def write(self, oprot):
21295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21297 
      return
21298 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
21299 
    if self.success is not None:
21300 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21301 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 21302 
      for iter487 in self.success:
21303 
        iter487.write(oprot)
4600 varun.gupt 21304 
      oprot.writeListEnd()
21305 
      oprot.writeFieldEnd()
21306 
    if self.ex is not None:
21307 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21308 
      self.ex.write(oprot)
21309 
      oprot.writeFieldEnd()
21310 
    oprot.writeFieldStop()
21311 
    oprot.writeStructEnd()
21312 
 
21313 
  def validate(self):
21314 
    return
21315 
 
21316 
 
21317 
  def __repr__(self):
21318 
    L = ['%s=%r' % (key, value)
21319 
      for key, value in self.__dict__.iteritems()]
21320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21321 
 
21322 
  def __eq__(self, other):
21323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21324 
 
21325 
  def __ne__(self, other):
21326 
    return not (self == other)
21327 
 
4607 rajveer 21328 
class getSlippedSippingDateOrders_args:
21329 
 
21330 
  thrift_spec = (
21331 
  )
21332 
 
21333 
  def read(self, iprot):
21334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21336 
      return
21337 
    iprot.readStructBegin()
21338 
    while True:
21339 
      (fname, ftype, fid) = iprot.readFieldBegin()
21340 
      if ftype == TType.STOP:
21341 
        break
21342 
      else:
21343 
        iprot.skip(ftype)
21344 
      iprot.readFieldEnd()
21345 
    iprot.readStructEnd()
21346 
 
21347 
  def write(self, oprot):
21348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21350 
      return
21351 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
21352 
    oprot.writeFieldStop()
21353 
    oprot.writeStructEnd()
21354 
 
21355 
  def validate(self):
21356 
    return
21357 
 
21358 
 
21359 
  def __repr__(self):
21360 
    L = ['%s=%r' % (key, value)
21361 
      for key, value in self.__dict__.iteritems()]
21362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21363 
 
21364 
  def __eq__(self, other):
21365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21366 
 
21367 
  def __ne__(self, other):
21368 
    return not (self == other)
21369 
 
21370 
class getSlippedSippingDateOrders_result:
21371 
  """
21372 
  Attributes:
21373 
   - success
21374 
   - ex
21375 
  """
21376 
 
21377 
  thrift_spec = (
21378 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21379 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21380 
  )
21381 
 
21382 
  def __init__(self, success=None, ex=None,):
21383 
    self.success = success
21384 
    self.ex = ex
21385 
 
21386 
  def read(self, iprot):
21387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21389 
      return
21390 
    iprot.readStructBegin()
21391 
    while True:
21392 
      (fname, ftype, fid) = iprot.readFieldBegin()
21393 
      if ftype == TType.STOP:
21394 
        break
21395 
      if fid == 0:
21396 
        if ftype == TType.LIST:
21397 
          self.success = []
5713 rajveer 21398 
          (_etype491, _size488) = iprot.readListBegin()
21399 
          for _i492 in xrange(_size488):
21400 
            _elem493 = Order()
21401 
            _elem493.read(iprot)
21402 
            self.success.append(_elem493)
4607 rajveer 21403 
          iprot.readListEnd()
21404 
        else:
21405 
          iprot.skip(ftype)
21406 
      elif fid == 1:
21407 
        if ftype == TType.STRUCT:
21408 
          self.ex = TransactionServiceException()
21409 
          self.ex.read(iprot)
21410 
        else:
21411 
          iprot.skip(ftype)
21412 
      else:
21413 
        iprot.skip(ftype)
21414 
      iprot.readFieldEnd()
21415 
    iprot.readStructEnd()
21416 
 
21417 
  def write(self, oprot):
21418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21420 
      return
21421 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
21422 
    if self.success is not None:
21423 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21424 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 21425 
      for iter494 in self.success:
21426 
        iter494.write(oprot)
4607 rajveer 21427 
      oprot.writeListEnd()
21428 
      oprot.writeFieldEnd()
21429 
    if self.ex is not None:
21430 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21431 
      self.ex.write(oprot)
21432 
      oprot.writeFieldEnd()
21433 
    oprot.writeFieldStop()
21434 
    oprot.writeStructEnd()
21435 
 
21436 
  def validate(self):
21437 
    return
21438 
 
21439 
 
21440 
  def __repr__(self):
21441 
    L = ['%s=%r' % (key, value)
21442 
      for key, value in self.__dict__.iteritems()]
21443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21444 
 
21445 
  def __eq__(self, other):
21446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21447 
 
21448 
  def __ne__(self, other):
21449 
    return not (self == other)
21450 
 
4709 rajveer 21451 
class getCancelledOrders_args:
21452 
  """
21453 
  Attributes:
21454 
   - cancelDateFrom
21455 
   - cancelDateTo
21456 
  """
21457 
 
21458 
  thrift_spec = (
21459 
    None, # 0
21460 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
21461 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
21462 
  )
21463 
 
21464 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
21465 
    self.cancelDateFrom = cancelDateFrom
21466 
    self.cancelDateTo = cancelDateTo
21467 
 
21468 
  def read(self, iprot):
21469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21471 
      return
21472 
    iprot.readStructBegin()
21473 
    while True:
21474 
      (fname, ftype, fid) = iprot.readFieldBegin()
21475 
      if ftype == TType.STOP:
21476 
        break
21477 
      if fid == 1:
21478 
        if ftype == TType.I64:
21479 
          self.cancelDateFrom = iprot.readI64();
21480 
        else:
21481 
          iprot.skip(ftype)
21482 
      elif fid == 2:
21483 
        if ftype == TType.I64:
21484 
          self.cancelDateTo = iprot.readI64();
21485 
        else:
21486 
          iprot.skip(ftype)
21487 
      else:
21488 
        iprot.skip(ftype)
21489 
      iprot.readFieldEnd()
21490 
    iprot.readStructEnd()
21491 
 
21492 
  def write(self, oprot):
21493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21495 
      return
21496 
    oprot.writeStructBegin('getCancelledOrders_args')
21497 
    if self.cancelDateFrom is not None:
21498 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
21499 
      oprot.writeI64(self.cancelDateFrom)
21500 
      oprot.writeFieldEnd()
21501 
    if self.cancelDateTo is not None:
21502 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
21503 
      oprot.writeI64(self.cancelDateTo)
21504 
      oprot.writeFieldEnd()
21505 
    oprot.writeFieldStop()
21506 
    oprot.writeStructEnd()
21507 
 
21508 
  def validate(self):
21509 
    return
21510 
 
21511 
 
21512 
  def __repr__(self):
21513 
    L = ['%s=%r' % (key, value)
21514 
      for key, value in self.__dict__.iteritems()]
21515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21516 
 
21517 
  def __eq__(self, other):
21518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21519 
 
21520 
  def __ne__(self, other):
21521 
    return not (self == other)
21522 
 
21523 
class getCancelledOrders_result:
21524 
  """
21525 
  Attributes:
21526 
   - success
21527 
   - ex
21528 
  """
21529 
 
21530 
  thrift_spec = (
21531 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21532 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21533 
  )
21534 
 
21535 
  def __init__(self, success=None, ex=None,):
21536 
    self.success = success
21537 
    self.ex = ex
21538 
 
21539 
  def read(self, iprot):
21540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21542 
      return
21543 
    iprot.readStructBegin()
21544 
    while True:
21545 
      (fname, ftype, fid) = iprot.readFieldBegin()
21546 
      if ftype == TType.STOP:
21547 
        break
21548 
      if fid == 0:
21549 
        if ftype == TType.LIST:
21550 
          self.success = []
5713 rajveer 21551 
          (_etype498, _size495) = iprot.readListBegin()
21552 
          for _i499 in xrange(_size495):
21553 
            _elem500 = Order()
21554 
            _elem500.read(iprot)
21555 
            self.success.append(_elem500)
4709 rajveer 21556 
          iprot.readListEnd()
21557 
        else:
21558 
          iprot.skip(ftype)
21559 
      elif fid == 1:
21560 
        if ftype == TType.STRUCT:
21561 
          self.ex = TransactionServiceException()
21562 
          self.ex.read(iprot)
21563 
        else:
21564 
          iprot.skip(ftype)
21565 
      else:
21566 
        iprot.skip(ftype)
21567 
      iprot.readFieldEnd()
21568 
    iprot.readStructEnd()
21569 
 
21570 
  def write(self, oprot):
21571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21573 
      return
21574 
    oprot.writeStructBegin('getCancelledOrders_result')
21575 
    if self.success is not None:
21576 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21577 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 21578 
      for iter501 in self.success:
21579 
        iter501.write(oprot)
4709 rajveer 21580 
      oprot.writeListEnd()
21581 
      oprot.writeFieldEnd()
21582 
    if self.ex is not None:
21583 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21584 
      self.ex.write(oprot)
21585 
      oprot.writeFieldEnd()
21586 
    oprot.writeFieldStop()
21587 
    oprot.writeStructEnd()
21588 
 
21589 
  def validate(self):
21590 
    return
21591 
 
21592 
 
21593 
  def __repr__(self):
21594 
    L = ['%s=%r' % (key, value)
21595 
      for key, value in self.__dict__.iteritems()]
21596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21597 
 
21598 
  def __eq__(self, other):
21599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21600 
 
21601 
  def __ne__(self, other):
21602 
    return not (self == other)
21603 
 
4600 varun.gupt 21604 
class saveBluedartSettlements_args:
21605 
  """
21606 
  Attributes:
21607 
   - mapAWBAndAmount
21608 
  """
21609 
 
21610 
  thrift_spec = (
21611 
    None, # 0
21612 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
21613 
  )
21614 
 
21615 
  def __init__(self, mapAWBAndAmount=None,):
21616 
    self.mapAWBAndAmount = mapAWBAndAmount
21617 
 
21618 
  def read(self, iprot):
21619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21621 
      return
21622 
    iprot.readStructBegin()
21623 
    while True:
21624 
      (fname, ftype, fid) = iprot.readFieldBegin()
21625 
      if ftype == TType.STOP:
21626 
        break
21627 
      if fid == 1:
21628 
        if ftype == TType.MAP:
21629 
          self.mapAWBAndAmount = {}
5713 rajveer 21630 
          (_ktype503, _vtype504, _size502 ) = iprot.readMapBegin()
21631 
          for _i506 in xrange(_size502):
21632 
            _key507 = iprot.readI64();
21633 
            _val508 = iprot.readDouble();
21634 
            self.mapAWBAndAmount[_key507] = _val508
4600 varun.gupt 21635 
          iprot.readMapEnd()
21636 
        else:
21637 
          iprot.skip(ftype)
21638 
      else:
21639 
        iprot.skip(ftype)
21640 
      iprot.readFieldEnd()
21641 
    iprot.readStructEnd()
21642 
 
21643 
  def write(self, oprot):
21644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21646 
      return
21647 
    oprot.writeStructBegin('saveBluedartSettlements_args')
21648 
    if self.mapAWBAndAmount is not None:
21649 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
21650 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5713 rajveer 21651 
      for kiter509,viter510 in self.mapAWBAndAmount.items():
21652 
        oprot.writeI64(kiter509)
21653 
        oprot.writeDouble(viter510)
4600 varun.gupt 21654 
      oprot.writeMapEnd()
21655 
      oprot.writeFieldEnd()
21656 
    oprot.writeFieldStop()
21657 
    oprot.writeStructEnd()
21658 
 
21659 
  def validate(self):
21660 
    return
21661 
 
21662 
 
21663 
  def __repr__(self):
21664 
    L = ['%s=%r' % (key, value)
21665 
      for key, value in self.__dict__.iteritems()]
21666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21667 
 
21668 
  def __eq__(self, other):
21669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21670 
 
21671 
  def __ne__(self, other):
21672 
    return not (self == other)
21673 
 
21674 
class saveBluedartSettlements_result:
21675 
  """
21676 
  Attributes:
21677 
   - ex
21678 
  """
21679 
 
21680 
  thrift_spec = (
21681 
    None, # 0
21682 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21683 
  )
21684 
 
21685 
  def __init__(self, ex=None,):
21686 
    self.ex = ex
21687 
 
21688 
  def read(self, iprot):
21689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21691 
      return
21692 
    iprot.readStructBegin()
21693 
    while True:
21694 
      (fname, ftype, fid) = iprot.readFieldBegin()
21695 
      if ftype == TType.STOP:
21696 
        break
21697 
      if fid == 1:
21698 
        if ftype == TType.STRUCT:
21699 
          self.ex = TransactionServiceException()
21700 
          self.ex.read(iprot)
21701 
        else:
21702 
          iprot.skip(ftype)
21703 
      else:
21704 
        iprot.skip(ftype)
21705 
      iprot.readFieldEnd()
21706 
    iprot.readStructEnd()
21707 
 
21708 
  def write(self, oprot):
21709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21711 
      return
21712 
    oprot.writeStructBegin('saveBluedartSettlements_result')
21713 
    if self.ex is not None:
21714 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21715 
      self.ex.write(oprot)
21716 
      oprot.writeFieldEnd()
21717 
    oprot.writeFieldStop()
21718 
    oprot.writeStructEnd()
21719 
 
21720 
  def validate(self):
21721 
    return
21722 
 
21723 
 
21724 
  def __repr__(self):
21725 
    L = ['%s=%r' % (key, value)
21726 
      for key, value in self.__dict__.iteritems()]
21727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21728 
 
21729 
  def __eq__(self, other):
21730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21731 
 
21732 
  def __ne__(self, other):
21733 
    return not (self == other)
21734 
 
21735 
class savePaymentSettlements_args:
21736 
  """
21737 
  Attributes:
21738 
   - settlementDate
21739 
   - paymentGatewayId
4905 varun.gupt 21740 
   - referenceId
4600 varun.gupt 21741 
   - serviceTax
21742 
   - otherCharges
21743 
   - netCollection
21744 
  """
21745 
 
21746 
  thrift_spec = (
21747 
    None, # 0
21748 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
21749 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 21750 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 21751 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
21752 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
21753 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
21754 
  )
21755 
 
4905 varun.gupt 21756 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 21757 
    self.settlementDate = settlementDate
21758 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 21759 
    self.referenceId = referenceId
4600 varun.gupt 21760 
    self.serviceTax = serviceTax
21761 
    self.otherCharges = otherCharges
21762 
    self.netCollection = netCollection
21763 
 
21764 
  def read(self, iprot):
21765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21767 
      return
21768 
    iprot.readStructBegin()
21769 
    while True:
21770 
      (fname, ftype, fid) = iprot.readFieldBegin()
21771 
      if ftype == TType.STOP:
21772 
        break
21773 
      if fid == 1:
21774 
        if ftype == TType.I64:
21775 
          self.settlementDate = iprot.readI64();
21776 
        else:
21777 
          iprot.skip(ftype)
21778 
      elif fid == 2:
21779 
        if ftype == TType.I64:
21780 
          self.paymentGatewayId = iprot.readI64();
21781 
        else:
21782 
          iprot.skip(ftype)
21783 
      elif fid == 3:
21784 
        if ftype == TType.I64:
4905 varun.gupt 21785 
          self.referenceId = iprot.readI64();
4600 varun.gupt 21786 
        else:
21787 
          iprot.skip(ftype)
21788 
      elif fid == 4:
21789 
        if ftype == TType.DOUBLE:
21790 
          self.serviceTax = iprot.readDouble();
21791 
        else:
21792 
          iprot.skip(ftype)
21793 
      elif fid == 5:
21794 
        if ftype == TType.DOUBLE:
21795 
          self.otherCharges = iprot.readDouble();
21796 
        else:
21797 
          iprot.skip(ftype)
21798 
      elif fid == 6:
21799 
        if ftype == TType.DOUBLE:
21800 
          self.netCollection = iprot.readDouble();
21801 
        else:
21802 
          iprot.skip(ftype)
21803 
      else:
21804 
        iprot.skip(ftype)
21805 
      iprot.readFieldEnd()
21806 
    iprot.readStructEnd()
21807 
 
21808 
  def write(self, oprot):
21809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21811 
      return
21812 
    oprot.writeStructBegin('savePaymentSettlements_args')
21813 
    if self.settlementDate is not None:
21814 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
21815 
      oprot.writeI64(self.settlementDate)
21816 
      oprot.writeFieldEnd()
21817 
    if self.paymentGatewayId is not None:
21818 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
21819 
      oprot.writeI64(self.paymentGatewayId)
21820 
      oprot.writeFieldEnd()
4905 varun.gupt 21821 
    if self.referenceId is not None:
21822 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
21823 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 21824 
      oprot.writeFieldEnd()
21825 
    if self.serviceTax is not None:
21826 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
21827 
      oprot.writeDouble(self.serviceTax)
21828 
      oprot.writeFieldEnd()
21829 
    if self.otherCharges is not None:
21830 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
21831 
      oprot.writeDouble(self.otherCharges)
21832 
      oprot.writeFieldEnd()
21833 
    if self.netCollection is not None:
21834 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
21835 
      oprot.writeDouble(self.netCollection)
21836 
      oprot.writeFieldEnd()
21837 
    oprot.writeFieldStop()
21838 
    oprot.writeStructEnd()
21839 
 
21840 
  def validate(self):
21841 
    return
21842 
 
21843 
 
21844 
  def __repr__(self):
21845 
    L = ['%s=%r' % (key, value)
21846 
      for key, value in self.__dict__.iteritems()]
21847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21848 
 
21849 
  def __eq__(self, other):
21850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21851 
 
21852 
  def __ne__(self, other):
21853 
    return not (self == other)
21854 
 
21855 
class savePaymentSettlements_result:
21856 
  """
21857 
  Attributes:
21858 
   - ex
21859 
  """
21860 
 
21861 
  thrift_spec = (
21862 
    None, # 0
21863 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21864 
  )
21865 
 
21866 
  def __init__(self, ex=None,):
21867 
    self.ex = ex
21868 
 
21869 
  def read(self, iprot):
21870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21872 
      return
21873 
    iprot.readStructBegin()
21874 
    while True:
21875 
      (fname, ftype, fid) = iprot.readFieldBegin()
21876 
      if ftype == TType.STOP:
21877 
        break
21878 
      if fid == 1:
21879 
        if ftype == TType.STRUCT:
21880 
          self.ex = TransactionServiceException()
21881 
          self.ex.read(iprot)
21882 
        else:
21883 
          iprot.skip(ftype)
21884 
      else:
21885 
        iprot.skip(ftype)
21886 
      iprot.readFieldEnd()
21887 
    iprot.readStructEnd()
21888 
 
21889 
  def write(self, oprot):
21890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21892 
      return
21893 
    oprot.writeStructBegin('savePaymentSettlements_result')
21894 
    if self.ex is not None:
21895 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21896 
      self.ex.write(oprot)
21897 
      oprot.writeFieldEnd()
21898 
    oprot.writeFieldStop()
21899 
    oprot.writeStructEnd()
21900 
 
21901 
  def validate(self):
21902 
    return
21903 
 
21904 
 
21905 
  def __repr__(self):
21906 
    L = ['%s=%r' % (key, value)
21907 
      for key, value in self.__dict__.iteritems()]
21908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21909 
 
21910 
  def __eq__(self, other):
21911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21912 
 
21913 
  def __ne__(self, other):
21914 
    return not (self == other)
21915 
 
21916 
class saveEBSSettlementSummary_args:
21917 
  """
21918 
  Attributes:
21919 
   - settlementId
21920 
   - settlementDate
21921 
   - transactionDateFrom
21922 
   - transactionDateTo
21923 
   - amount
21924 
  """
21925 
 
21926 
  thrift_spec = (
21927 
    None, # 0
21928 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21929 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
21930 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
21931 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
21932 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
21933 
  )
21934 
 
21935 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
21936 
    self.settlementId = settlementId
21937 
    self.settlementDate = settlementDate
21938 
    self.transactionDateFrom = transactionDateFrom
21939 
    self.transactionDateTo = transactionDateTo
21940 
    self.amount = amount
21941 
 
21942 
  def read(self, iprot):
21943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21945 
      return
21946 
    iprot.readStructBegin()
21947 
    while True:
21948 
      (fname, ftype, fid) = iprot.readFieldBegin()
21949 
      if ftype == TType.STOP:
21950 
        break
21951 
      if fid == 1:
21952 
        if ftype == TType.I64:
21953 
          self.settlementId = iprot.readI64();
21954 
        else:
21955 
          iprot.skip(ftype)
21956 
      elif fid == 2:
21957 
        if ftype == TType.I64:
21958 
          self.settlementDate = iprot.readI64();
21959 
        else:
21960 
          iprot.skip(ftype)
21961 
      elif fid == 3:
21962 
        if ftype == TType.I64:
21963 
          self.transactionDateFrom = iprot.readI64();
21964 
        else:
21965 
          iprot.skip(ftype)
21966 
      elif fid == 4:
21967 
        if ftype == TType.I64:
21968 
          self.transactionDateTo = iprot.readI64();
21969 
        else:
21970 
          iprot.skip(ftype)
21971 
      elif fid == 5:
21972 
        if ftype == TType.DOUBLE:
21973 
          self.amount = iprot.readDouble();
21974 
        else:
21975 
          iprot.skip(ftype)
21976 
      else:
21977 
        iprot.skip(ftype)
21978 
      iprot.readFieldEnd()
21979 
    iprot.readStructEnd()
21980 
 
21981 
  def write(self, oprot):
21982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21984 
      return
21985 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
21986 
    if self.settlementId is not None:
21987 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21988 
      oprot.writeI64(self.settlementId)
21989 
      oprot.writeFieldEnd()
21990 
    if self.settlementDate is not None:
21991 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
21992 
      oprot.writeI64(self.settlementDate)
21993 
      oprot.writeFieldEnd()
21994 
    if self.transactionDateFrom is not None:
21995 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
21996 
      oprot.writeI64(self.transactionDateFrom)
21997 
      oprot.writeFieldEnd()
21998 
    if self.transactionDateTo is not None:
21999 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
22000 
      oprot.writeI64(self.transactionDateTo)
22001 
      oprot.writeFieldEnd()
22002 
    if self.amount is not None:
22003 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
22004 
      oprot.writeDouble(self.amount)
22005 
      oprot.writeFieldEnd()
22006 
    oprot.writeFieldStop()
22007 
    oprot.writeStructEnd()
22008 
 
22009 
  def validate(self):
22010 
    return
22011 
 
22012 
 
22013 
  def __repr__(self):
22014 
    L = ['%s=%r' % (key, value)
22015 
      for key, value in self.__dict__.iteritems()]
22016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22017 
 
22018 
  def __eq__(self, other):
22019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22020 
 
22021 
  def __ne__(self, other):
22022 
    return not (self == other)
22023 
 
22024 
class saveEBSSettlementSummary_result:
22025 
  """
22026 
  Attributes:
22027 
   - ex
22028 
  """
22029 
 
22030 
  thrift_spec = (
22031 
    None, # 0
22032 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22033 
  )
22034 
 
22035 
  def __init__(self, ex=None,):
22036 
    self.ex = ex
22037 
 
22038 
  def read(self, iprot):
22039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22041 
      return
22042 
    iprot.readStructBegin()
22043 
    while True:
22044 
      (fname, ftype, fid) = iprot.readFieldBegin()
22045 
      if ftype == TType.STOP:
22046 
        break
22047 
      if fid == 1:
22048 
        if ftype == TType.STRUCT:
22049 
          self.ex = TransactionServiceException()
22050 
          self.ex.read(iprot)
22051 
        else:
22052 
          iprot.skip(ftype)
22053 
      else:
22054 
        iprot.skip(ftype)
22055 
      iprot.readFieldEnd()
22056 
    iprot.readStructEnd()
22057 
 
22058 
  def write(self, oprot):
22059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22061 
      return
22062 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
22063 
    if self.ex is not None:
22064 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22065 
      self.ex.write(oprot)
22066 
      oprot.writeFieldEnd()
22067 
    oprot.writeFieldStop()
22068 
    oprot.writeStructEnd()
22069 
 
22070 
  def validate(self):
22071 
    return
22072 
 
22073 
 
22074 
  def __repr__(self):
22075 
    L = ['%s=%r' % (key, value)
22076 
      for key, value in self.__dict__.iteritems()]
22077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22078 
 
22079 
  def __eq__(self, other):
22080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22081 
 
22082 
  def __ne__(self, other):
22083 
    return not (self == other)
22084 
 
5386 phani.kuma 22085 
class getSettlementForPrepaid_args:
4600 varun.gupt 22086 
  """
22087 
  Attributes:
5189 varun.gupt 22088 
   - referenceId
22089 
   - isRefund
4600 varun.gupt 22090 
  """
22091 
 
22092 
  thrift_spec = (
22093 
    None, # 0
5189 varun.gupt 22094 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 22095 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 22096 
  )
22097 
 
5386 phani.kuma 22098 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 22099 
    self.referenceId = referenceId
22100 
    self.isRefund = isRefund
4600 varun.gupt 22101 
 
22102 
  def read(self, iprot):
22103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22105 
      return
22106 
    iprot.readStructBegin()
22107 
    while True:
22108 
      (fname, ftype, fid) = iprot.readFieldBegin()
22109 
      if ftype == TType.STOP:
22110 
        break
22111 
      if fid == 1:
22112 
        if ftype == TType.I64:
5189 varun.gupt 22113 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22114 
        else:
22115 
          iprot.skip(ftype)
5189 varun.gupt 22116 
      elif fid == 2:
22117 
        if ftype == TType.BOOL:
22118 
          self.isRefund = iprot.readBool();
22119 
        else:
22120 
          iprot.skip(ftype)
4600 varun.gupt 22121 
      else:
22122 
        iprot.skip(ftype)
22123 
      iprot.readFieldEnd()
22124 
    iprot.readStructEnd()
22125 
 
22126 
  def write(self, oprot):
22127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22129 
      return
5386 phani.kuma 22130 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 22131 
    if self.referenceId is not None:
22132 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
22133 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22134 
      oprot.writeFieldEnd()
5386 phani.kuma 22135 
    if self.isRefund is not None:
22136 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
22137 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 22138 
      oprot.writeFieldEnd()
5386 phani.kuma 22139 
    oprot.writeFieldStop()
22140 
    oprot.writeStructEnd()
22141 
 
22142 
  def validate(self):
22143 
    return
22144 
 
22145 
 
22146 
  def __repr__(self):
22147 
    L = ['%s=%r' % (key, value)
22148 
      for key, value in self.__dict__.iteritems()]
22149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22150 
 
22151 
  def __eq__(self, other):
22152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22153 
 
22154 
  def __ne__(self, other):
22155 
    return not (self == other)
22156 
 
22157 
class getSettlementForPrepaid_result:
22158 
  """
22159 
  Attributes:
22160 
   - success
22161 
   - ex
22162 
  """
22163 
 
22164 
  thrift_spec = (
22165 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22166 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22167 
  )
22168 
 
22169 
  def __init__(self, success=None, ex=None,):
22170 
    self.success = success
22171 
    self.ex = ex
22172 
 
22173 
  def read(self, iprot):
22174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22176 
      return
22177 
    iprot.readStructBegin()
22178 
    while True:
22179 
      (fname, ftype, fid) = iprot.readFieldBegin()
22180 
      if ftype == TType.STOP:
22181 
        break
22182 
      if fid == 0:
22183 
        if ftype == TType.STRUCT:
22184 
          self.success = PaymentSettlement()
22185 
          self.success.read(iprot)
22186 
        else:
22187 
          iprot.skip(ftype)
22188 
      elif fid == 1:
22189 
        if ftype == TType.STRUCT:
22190 
          self.ex = TransactionServiceException()
22191 
          self.ex.read(iprot)
22192 
        else:
22193 
          iprot.skip(ftype)
22194 
      else:
22195 
        iprot.skip(ftype)
22196 
      iprot.readFieldEnd()
22197 
    iprot.readStructEnd()
22198 
 
22199 
  def write(self, oprot):
22200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22202 
      return
22203 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
22204 
    if self.success is not None:
22205 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22206 
      self.success.write(oprot)
22207 
      oprot.writeFieldEnd()
22208 
    if self.ex is not None:
22209 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22210 
      self.ex.write(oprot)
22211 
      oprot.writeFieldEnd()
22212 
    oprot.writeFieldStop()
22213 
    oprot.writeStructEnd()
22214 
 
22215 
  def validate(self):
22216 
    return
22217 
 
22218 
 
22219 
  def __repr__(self):
22220 
    L = ['%s=%r' % (key, value)
22221 
      for key, value in self.__dict__.iteritems()]
22222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22223 
 
22224 
  def __eq__(self, other):
22225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22226 
 
22227 
  def __ne__(self, other):
22228 
    return not (self == other)
22229 
 
22230 
class getSettlementForCod_args:
22231 
  """
22232 
  Attributes:
22233 
   - orderId
22234 
   - isRefund
22235 
  """
22236 
 
22237 
  thrift_spec = (
22238 
    None, # 0
22239 
    (1, TType.I64, 'orderId', None, None, ), # 1
22240 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
22241 
  )
22242 
 
22243 
  def __init__(self, orderId=None, isRefund=None,):
22244 
    self.orderId = orderId
22245 
    self.isRefund = isRefund
22246 
 
22247 
  def read(self, iprot):
22248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22250 
      return
22251 
    iprot.readStructBegin()
22252 
    while True:
22253 
      (fname, ftype, fid) = iprot.readFieldBegin()
22254 
      if ftype == TType.STOP:
22255 
        break
22256 
      if fid == 1:
22257 
        if ftype == TType.I64:
22258 
          self.orderId = iprot.readI64();
22259 
        else:
22260 
          iprot.skip(ftype)
22261 
      elif fid == 2:
22262 
        if ftype == TType.BOOL:
22263 
          self.isRefund = iprot.readBool();
22264 
        else:
22265 
          iprot.skip(ftype)
22266 
      else:
22267 
        iprot.skip(ftype)
22268 
      iprot.readFieldEnd()
22269 
    iprot.readStructEnd()
22270 
 
22271 
  def write(self, oprot):
22272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22274 
      return
22275 
    oprot.writeStructBegin('getSettlementForCod_args')
22276 
    if self.orderId is not None:
22277 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22278 
      oprot.writeI64(self.orderId)
22279 
      oprot.writeFieldEnd()
5189 varun.gupt 22280 
    if self.isRefund is not None:
5386 phani.kuma 22281 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 22282 
      oprot.writeBool(self.isRefund)
22283 
      oprot.writeFieldEnd()
4600 varun.gupt 22284 
    oprot.writeFieldStop()
22285 
    oprot.writeStructEnd()
22286 
 
22287 
  def validate(self):
22288 
    return
22289 
 
22290 
 
22291 
  def __repr__(self):
22292 
    L = ['%s=%r' % (key, value)
22293 
      for key, value in self.__dict__.iteritems()]
22294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22295 
 
22296 
  def __eq__(self, other):
22297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22298 
 
22299 
  def __ne__(self, other):
22300 
    return not (self == other)
22301 
 
5386 phani.kuma 22302 
class getSettlementForCod_result:
4600 varun.gupt 22303 
  """
22304 
  Attributes:
22305 
   - success
22306 
   - ex
22307 
  """
22308 
 
22309 
  thrift_spec = (
22310 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22311 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22312 
  )
22313 
 
22314 
  def __init__(self, success=None, ex=None,):
22315 
    self.success = success
22316 
    self.ex = ex
22317 
 
22318 
  def read(self, iprot):
22319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22321 
      return
22322 
    iprot.readStructBegin()
22323 
    while True:
22324 
      (fname, ftype, fid) = iprot.readFieldBegin()
22325 
      if ftype == TType.STOP:
22326 
        break
22327 
      if fid == 0:
22328 
        if ftype == TType.STRUCT:
22329 
          self.success = PaymentSettlement()
22330 
          self.success.read(iprot)
22331 
        else:
22332 
          iprot.skip(ftype)
22333 
      elif fid == 1:
22334 
        if ftype == TType.STRUCT:
22335 
          self.ex = TransactionServiceException()
22336 
          self.ex.read(iprot)
22337 
        else:
22338 
          iprot.skip(ftype)
22339 
      else:
22340 
        iprot.skip(ftype)
22341 
      iprot.readFieldEnd()
22342 
    iprot.readStructEnd()
22343 
 
22344 
  def write(self, oprot):
22345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22347 
      return
5386 phani.kuma 22348 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 22349 
    if self.success is not None:
22350 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22351 
      self.success.write(oprot)
22352 
      oprot.writeFieldEnd()
22353 
    if self.ex is not None:
22354 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22355 
      self.ex.write(oprot)
22356 
      oprot.writeFieldEnd()
22357 
    oprot.writeFieldStop()
22358 
    oprot.writeStructEnd()
22359 
 
22360 
  def validate(self):
22361 
    return
22362 
 
22363 
 
22364 
  def __repr__(self):
22365 
    L = ['%s=%r' % (key, value)
22366 
      for key, value in self.__dict__.iteritems()]
22367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22368 
 
22369 
  def __eq__(self, other):
22370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22371 
 
22372 
  def __ne__(self, other):
22373 
    return not (self == other)
22374 
 
22375 
class getEBSSettlementSummaries_args:
22376 
 
22377 
  thrift_spec = (
22378 
  )
22379 
 
22380 
  def read(self, iprot):
22381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22383 
      return
22384 
    iprot.readStructBegin()
22385 
    while True:
22386 
      (fname, ftype, fid) = iprot.readFieldBegin()
22387 
      if ftype == TType.STOP:
22388 
        break
22389 
      else:
22390 
        iprot.skip(ftype)
22391 
      iprot.readFieldEnd()
22392 
    iprot.readStructEnd()
22393 
 
22394 
  def write(self, oprot):
22395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22397 
      return
22398 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
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 
 
22417 
class getEBSSettlementSummaries_result:
22418 
  """
22419 
  Attributes:
22420 
   - success
22421 
   - ex
22422 
  """
22423 
 
22424 
  thrift_spec = (
22425 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), 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.MAP:
22444 
          self.success = {}
5713 rajveer 22445 
          (_ktype512, _vtype513, _size511 ) = iprot.readMapBegin()
22446 
          for _i515 in xrange(_size511):
22447 
            _key516 = iprot.readI64();
22448 
            _val517 = iprot.readString();
22449 
            self.success[_key516] = _val517
4600 varun.gupt 22450 
          iprot.readMapEnd()
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
22468 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
22469 
    if self.success is not None:
22470 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22471 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5713 rajveer 22472 
      for kiter518,viter519 in self.success.items():
22473 
        oprot.writeI64(kiter518)
22474 
        oprot.writeString(viter519)
4600 varun.gupt 22475 
      oprot.writeMapEnd()
22476 
      oprot.writeFieldEnd()
22477 
    if self.ex is not None:
22478 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22479 
      self.ex.write(oprot)
22480 
      oprot.writeFieldEnd()
22481 
    oprot.writeFieldStop()
22482 
    oprot.writeStructEnd()
22483 
 
22484 
  def validate(self):
22485 
    return
22486 
 
22487 
 
22488 
  def __repr__(self):
22489 
    L = ['%s=%r' % (key, value)
22490 
      for key, value in self.__dict__.iteritems()]
22491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22492 
 
22493 
  def __eq__(self, other):
22494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22495 
 
22496 
  def __ne__(self, other):
22497 
    return not (self == other)
22498 
 
22499 
class markEBSSettlementUploaded_args:
22500 
  """
22501 
  Attributes:
22502 
   - settlementId
22503 
  """
22504 
 
22505 
  thrift_spec = (
22506 
    None, # 0
22507 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22508 
  )
22509 
 
22510 
  def __init__(self, settlementId=None,):
22511 
    self.settlementId = settlementId
22512 
 
22513 
  def read(self, iprot):
22514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22516 
      return
22517 
    iprot.readStructBegin()
22518 
    while True:
22519 
      (fname, ftype, fid) = iprot.readFieldBegin()
22520 
      if ftype == TType.STOP:
22521 
        break
22522 
      if fid == 1:
22523 
        if ftype == TType.I64:
22524 
          self.settlementId = iprot.readI64();
22525 
        else:
22526 
          iprot.skip(ftype)
22527 
      else:
22528 
        iprot.skip(ftype)
22529 
      iprot.readFieldEnd()
22530 
    iprot.readStructEnd()
22531 
 
22532 
  def write(self, oprot):
22533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22535 
      return
22536 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
22537 
    if self.settlementId is not None:
22538 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22539 
      oprot.writeI64(self.settlementId)
22540 
      oprot.writeFieldEnd()
22541 
    oprot.writeFieldStop()
22542 
    oprot.writeStructEnd()
22543 
 
22544 
  def validate(self):
22545 
    return
22546 
 
22547 
 
22548 
  def __repr__(self):
22549 
    L = ['%s=%r' % (key, value)
22550 
      for key, value in self.__dict__.iteritems()]
22551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22552 
 
22553 
  def __eq__(self, other):
22554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22555 
 
22556 
  def __ne__(self, other):
22557 
    return not (self == other)
22558 
 
22559 
class markEBSSettlementUploaded_result:
22560 
  """
22561 
  Attributes:
22562 
   - ex
22563 
  """
22564 
 
22565 
  thrift_spec = (
22566 
    None, # 0
22567 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22568 
  )
22569 
 
22570 
  def __init__(self, ex=None,):
22571 
    self.ex = ex
22572 
 
22573 
  def read(self, iprot):
22574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22576 
      return
22577 
    iprot.readStructBegin()
22578 
    while True:
22579 
      (fname, ftype, fid) = iprot.readFieldBegin()
22580 
      if ftype == TType.STOP:
22581 
        break
22582 
      if fid == 1:
22583 
        if ftype == TType.STRUCT:
22584 
          self.ex = TransactionServiceException()
22585 
          self.ex.read(iprot)
22586 
        else:
22587 
          iprot.skip(ftype)
22588 
      else:
22589 
        iprot.skip(ftype)
22590 
      iprot.readFieldEnd()
22591 
    iprot.readStructEnd()
22592 
 
22593 
  def write(self, oprot):
22594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22596 
      return
22597 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
22598 
    if self.ex is not None:
22599 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22600 
      self.ex.write(oprot)
22601 
      oprot.writeFieldEnd()
22602 
    oprot.writeFieldStop()
22603 
    oprot.writeStructEnd()
22604 
 
22605 
  def validate(self):
22606 
    return
22607 
 
22608 
 
22609 
  def __repr__(self):
22610 
    L = ['%s=%r' % (key, value)
22611 
      for key, value in self.__dict__.iteritems()]
22612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22613 
 
22614 
  def __eq__(self, other):
22615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22616 
 
22617 
  def __ne__(self, other):
22618 
    return not (self == other)
22619 
 
22620 
class getEBSSettlementDate_args:
22621 
  """
22622 
  Attributes:
22623 
   - settlementId
22624 
  """
22625 
 
22626 
  thrift_spec = (
22627 
    None, # 0
22628 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22629 
  )
22630 
 
22631 
  def __init__(self, settlementId=None,):
22632 
    self.settlementId = settlementId
22633 
 
22634 
  def read(self, iprot):
22635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22637 
      return
22638 
    iprot.readStructBegin()
22639 
    while True:
22640 
      (fname, ftype, fid) = iprot.readFieldBegin()
22641 
      if ftype == TType.STOP:
22642 
        break
22643 
      if fid == 1:
22644 
        if ftype == TType.I64:
22645 
          self.settlementId = iprot.readI64();
22646 
        else:
22647 
          iprot.skip(ftype)
22648 
      else:
22649 
        iprot.skip(ftype)
22650 
      iprot.readFieldEnd()
22651 
    iprot.readStructEnd()
22652 
 
22653 
  def write(self, oprot):
22654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22656 
      return
22657 
    oprot.writeStructBegin('getEBSSettlementDate_args')
22658 
    if self.settlementId is not None:
22659 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22660 
      oprot.writeI64(self.settlementId)
22661 
      oprot.writeFieldEnd()
22662 
    oprot.writeFieldStop()
22663 
    oprot.writeStructEnd()
22664 
 
22665 
  def validate(self):
22666 
    return
22667 
 
22668 
 
22669 
  def __repr__(self):
22670 
    L = ['%s=%r' % (key, value)
22671 
      for key, value in self.__dict__.iteritems()]
22672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22673 
 
22674 
  def __eq__(self, other):
22675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22676 
 
22677 
  def __ne__(self, other):
22678 
    return not (self == other)
22679 
 
22680 
class getEBSSettlementDate_result:
22681 
  """
22682 
  Attributes:
22683 
   - success
22684 
   - ex
22685 
  """
22686 
 
22687 
  thrift_spec = (
22688 
    (0, TType.I64, 'success', None, None, ), # 0
22689 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22690 
  )
22691 
 
22692 
  def __init__(self, success=None, ex=None,):
22693 
    self.success = success
22694 
    self.ex = ex
22695 
 
22696 
  def read(self, iprot):
22697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22699 
      return
22700 
    iprot.readStructBegin()
22701 
    while True:
22702 
      (fname, ftype, fid) = iprot.readFieldBegin()
22703 
      if ftype == TType.STOP:
22704 
        break
22705 
      if fid == 0:
22706 
        if ftype == TType.I64:
22707 
          self.success = iprot.readI64();
22708 
        else:
22709 
          iprot.skip(ftype)
22710 
      elif fid == 1:
22711 
        if ftype == TType.STRUCT:
22712 
          self.ex = TransactionServiceException()
22713 
          self.ex.read(iprot)
22714 
        else:
22715 
          iprot.skip(ftype)
22716 
      else:
22717 
        iprot.skip(ftype)
22718 
      iprot.readFieldEnd()
22719 
    iprot.readStructEnd()
22720 
 
22721 
  def write(self, oprot):
22722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22724 
      return
22725 
    oprot.writeStructBegin('getEBSSettlementDate_result')
22726 
    if self.success is not None:
22727 
      oprot.writeFieldBegin('success', TType.I64, 0)
22728 
      oprot.writeI64(self.success)
22729 
      oprot.writeFieldEnd()
22730 
    if self.ex is not None:
22731 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22732 
      self.ex.write(oprot)
22733 
      oprot.writeFieldEnd()
22734 
    oprot.writeFieldStop()
22735 
    oprot.writeStructEnd()
22736 
 
22737 
  def validate(self):
22738 
    return
22739 
 
22740 
 
22741 
  def __repr__(self):
22742 
    L = ['%s=%r' % (key, value)
22743 
      for key, value in self.__dict__.iteritems()]
22744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22745 
 
22746 
  def __eq__(self, other):
22747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22748 
 
22749 
  def __ne__(self, other):
22750 
    return not (self == other)
4715 varun.gupt 22751 
 
22752 
class getSettlementsByDate_args:
22753 
  """
22754 
  Attributes:
22755 
   - settlementDateFrom
22756 
   - settlementDateTo
22757 
   - isRefund
22758 
  """
22759 
 
22760 
  thrift_spec = (
22761 
    None, # 0
22762 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
22763 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
22764 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
22765 
  )
22766 
 
22767 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
22768 
    self.settlementDateFrom = settlementDateFrom
22769 
    self.settlementDateTo = settlementDateTo
22770 
    self.isRefund = isRefund
22771 
 
22772 
  def read(self, iprot):
22773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22775 
      return
22776 
    iprot.readStructBegin()
22777 
    while True:
22778 
      (fname, ftype, fid) = iprot.readFieldBegin()
22779 
      if ftype == TType.STOP:
22780 
        break
22781 
      if fid == 1:
22782 
        if ftype == TType.I64:
22783 
          self.settlementDateFrom = iprot.readI64();
22784 
        else:
22785 
          iprot.skip(ftype)
22786 
      elif fid == 2:
22787 
        if ftype == TType.I64:
22788 
          self.settlementDateTo = iprot.readI64();
22789 
        else:
22790 
          iprot.skip(ftype)
22791 
      elif fid == 3:
22792 
        if ftype == TType.BOOL:
22793 
          self.isRefund = iprot.readBool();
22794 
        else:
22795 
          iprot.skip(ftype)
22796 
      else:
22797 
        iprot.skip(ftype)
22798 
      iprot.readFieldEnd()
22799 
    iprot.readStructEnd()
22800 
 
22801 
  def write(self, oprot):
22802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22804 
      return
22805 
    oprot.writeStructBegin('getSettlementsByDate_args')
22806 
    if self.settlementDateFrom is not None:
22807 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
22808 
      oprot.writeI64(self.settlementDateFrom)
22809 
      oprot.writeFieldEnd()
22810 
    if self.settlementDateTo is not None:
22811 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
22812 
      oprot.writeI64(self.settlementDateTo)
22813 
      oprot.writeFieldEnd()
22814 
    if self.isRefund is not None:
22815 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
22816 
      oprot.writeBool(self.isRefund)
22817 
      oprot.writeFieldEnd()
22818 
    oprot.writeFieldStop()
22819 
    oprot.writeStructEnd()
22820 
 
22821 
  def validate(self):
22822 
    return
22823 
 
22824 
 
22825 
  def __repr__(self):
22826 
    L = ['%s=%r' % (key, value)
22827 
      for key, value in self.__dict__.iteritems()]
22828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22829 
 
22830 
  def __eq__(self, other):
22831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22832 
 
22833 
  def __ne__(self, other):
22834 
    return not (self == other)
22835 
 
22836 
class getSettlementsByDate_result:
22837 
  """
22838 
  Attributes:
22839 
   - success
22840 
   - ex
22841 
  """
22842 
 
22843 
  thrift_spec = (
22844 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
22845 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22846 
  )
22847 
 
22848 
  def __init__(self, success=None, ex=None,):
22849 
    self.success = success
22850 
    self.ex = ex
22851 
 
22852 
  def read(self, iprot):
22853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22855 
      return
22856 
    iprot.readStructBegin()
22857 
    while True:
22858 
      (fname, ftype, fid) = iprot.readFieldBegin()
22859 
      if ftype == TType.STOP:
22860 
        break
22861 
      if fid == 0:
22862 
        if ftype == TType.LIST:
22863 
          self.success = []
5713 rajveer 22864 
          (_etype523, _size520) = iprot.readListBegin()
22865 
          for _i524 in xrange(_size520):
22866 
            _elem525 = PaymentSettlement()
22867 
            _elem525.read(iprot)
22868 
            self.success.append(_elem525)
4715 varun.gupt 22869 
          iprot.readListEnd()
22870 
        else:
22871 
          iprot.skip(ftype)
22872 
      elif fid == 1:
22873 
        if ftype == TType.STRUCT:
22874 
          self.ex = TransactionServiceException()
22875 
          self.ex.read(iprot)
22876 
        else:
22877 
          iprot.skip(ftype)
22878 
      else:
22879 
        iprot.skip(ftype)
22880 
      iprot.readFieldEnd()
22881 
    iprot.readStructEnd()
22882 
 
22883 
  def write(self, oprot):
22884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22886 
      return
22887 
    oprot.writeStructBegin('getSettlementsByDate_result')
22888 
    if self.success is not None:
22889 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22890 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 22891 
      for iter526 in self.success:
22892 
        iter526.write(oprot)
4715 varun.gupt 22893 
      oprot.writeListEnd()
22894 
      oprot.writeFieldEnd()
22895 
    if self.ex is not None:
22896 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22897 
      self.ex.write(oprot)
22898 
      oprot.writeFieldEnd()
22899 
    oprot.writeFieldStop()
22900 
    oprot.writeStructEnd()
22901 
 
22902 
  def validate(self):
22903 
    return
22904 
 
22905 
 
22906 
  def __repr__(self):
22907 
    L = ['%s=%r' % (key, value)
22908 
      for key, value in self.__dict__.iteritems()]
22909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22910 
 
22911 
  def __eq__(self, other):
22912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22913 
 
22914 
  def __ne__(self, other):
22915 
    return not (self == other)
22916 
 
22917 
class getReshippedOrderIds_args:
22918 
  """
22919 
  Attributes:
22920 
   - orderIds
22921 
  """
22922 
 
22923 
  thrift_spec = (
22924 
    None, # 0
22925 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
22926 
  )
22927 
 
22928 
  def __init__(self, orderIds=None,):
22929 
    self.orderIds = orderIds
22930 
 
22931 
  def read(self, iprot):
22932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22934 
      return
22935 
    iprot.readStructBegin()
22936 
    while True:
22937 
      (fname, ftype, fid) = iprot.readFieldBegin()
22938 
      if ftype == TType.STOP:
22939 
        break
22940 
      if fid == 1:
22941 
        if ftype == TType.LIST:
22942 
          self.orderIds = []
5713 rajveer 22943 
          (_etype530, _size527) = iprot.readListBegin()
22944 
          for _i531 in xrange(_size527):
22945 
            _elem532 = iprot.readI64();
22946 
            self.orderIds.append(_elem532)
4715 varun.gupt 22947 
          iprot.readListEnd()
22948 
        else:
22949 
          iprot.skip(ftype)
22950 
      else:
22951 
        iprot.skip(ftype)
22952 
      iprot.readFieldEnd()
22953 
    iprot.readStructEnd()
22954 
 
22955 
  def write(self, oprot):
22956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22958 
      return
22959 
    oprot.writeStructBegin('getReshippedOrderIds_args')
22960 
    if self.orderIds is not None:
22961 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
22962 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5713 rajveer 22963 
      for iter533 in self.orderIds:
22964 
        oprot.writeI64(iter533)
4715 varun.gupt 22965 
      oprot.writeListEnd()
22966 
      oprot.writeFieldEnd()
22967 
    oprot.writeFieldStop()
22968 
    oprot.writeStructEnd()
22969 
 
22970 
  def validate(self):
22971 
    return
22972 
 
22973 
 
22974 
  def __repr__(self):
22975 
    L = ['%s=%r' % (key, value)
22976 
      for key, value in self.__dict__.iteritems()]
22977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22978 
 
22979 
  def __eq__(self, other):
22980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22981 
 
22982 
  def __ne__(self, other):
22983 
    return not (self == other)
22984 
 
22985 
class getReshippedOrderIds_result:
22986 
  """
22987 
  Attributes:
22988 
   - success
22989 
   - ex
22990 
  """
22991 
 
22992 
  thrift_spec = (
22993 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
22994 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22995 
  )
22996 
 
22997 
  def __init__(self, success=None, ex=None,):
22998 
    self.success = success
22999 
    self.ex = ex
23000 
 
23001 
  def read(self, iprot):
23002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23004 
      return
23005 
    iprot.readStructBegin()
23006 
    while True:
23007 
      (fname, ftype, fid) = iprot.readFieldBegin()
23008 
      if ftype == TType.STOP:
23009 
        break
23010 
      if fid == 0:
23011 
        if ftype == TType.LIST:
23012 
          self.success = []
5713 rajveer 23013 
          (_etype537, _size534) = iprot.readListBegin()
23014 
          for _i538 in xrange(_size534):
23015 
            _elem539 = iprot.readI64();
23016 
            self.success.append(_elem539)
4715 varun.gupt 23017 
          iprot.readListEnd()
23018 
        else:
23019 
          iprot.skip(ftype)
23020 
      elif fid == 1:
23021 
        if ftype == TType.STRUCT:
23022 
          self.ex = TransactionServiceException()
23023 
          self.ex.read(iprot)
23024 
        else:
23025 
          iprot.skip(ftype)
23026 
      else:
23027 
        iprot.skip(ftype)
23028 
      iprot.readFieldEnd()
23029 
    iprot.readStructEnd()
23030 
 
23031 
  def write(self, oprot):
23032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23034 
      return
23035 
    oprot.writeStructBegin('getReshippedOrderIds_result')
23036 
    if self.success is not None:
23037 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23038 
      oprot.writeListBegin(TType.I64, len(self.success))
5713 rajveer 23039 
      for iter540 in self.success:
23040 
        oprot.writeI64(iter540)
4715 varun.gupt 23041 
      oprot.writeListEnd()
23042 
      oprot.writeFieldEnd()
23043 
    if self.ex is not None:
23044 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23045 
      self.ex.write(oprot)
23046 
      oprot.writeFieldEnd()
23047 
    oprot.writeFieldStop()
23048 
    oprot.writeStructEnd()
23049 
 
23050 
  def validate(self):
23051 
    return
23052 
 
23053 
 
23054 
  def __repr__(self):
23055 
    L = ['%s=%r' % (key, value)
23056 
      for key, value in self.__dict__.iteritems()]
23057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23058 
 
23059 
  def __eq__(self, other):
23060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23061 
 
23062 
  def __ne__(self, other):
23063 
    return not (self == other)
4757 mandeep.dh 23064 
 
5481 phani.kuma 23065 
class getBilledOrders_args:
4875 varun.gupt 23066 
  """
23067 
  Attributes:
23068 
   - vendorId
5481 phani.kuma 23069 
   - onlyVendorNotPaid
23070 
   - billingDateFrom
23071 
   - billingDateTo
4875 varun.gupt 23072 
  """
23073 
 
23074 
  thrift_spec = (
23075 
    None, # 0
23076 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 23077 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
23078 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
23079 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 23080 
  )
23081 
 
5481 phani.kuma 23082 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 23083 
    self.vendorId = vendorId
5481 phani.kuma 23084 
    self.onlyVendorNotPaid = onlyVendorNotPaid
23085 
    self.billingDateFrom = billingDateFrom
23086 
    self.billingDateTo = billingDateTo
4875 varun.gupt 23087 
 
23088 
  def read(self, iprot):
23089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23091 
      return
23092 
    iprot.readStructBegin()
23093 
    while True:
23094 
      (fname, ftype, fid) = iprot.readFieldBegin()
23095 
      if ftype == TType.STOP:
23096 
        break
23097 
      if fid == 1:
23098 
        if ftype == TType.I64:
23099 
          self.vendorId = iprot.readI64();
23100 
        else:
23101 
          iprot.skip(ftype)
5481 phani.kuma 23102 
      elif fid == 2:
23103 
        if ftype == TType.BOOL:
23104 
          self.onlyVendorNotPaid = iprot.readBool();
23105 
        else:
23106 
          iprot.skip(ftype)
23107 
      elif fid == 3:
23108 
        if ftype == TType.I64:
23109 
          self.billingDateFrom = iprot.readI64();
23110 
        else:
23111 
          iprot.skip(ftype)
23112 
      elif fid == 4:
23113 
        if ftype == TType.I64:
23114 
          self.billingDateTo = iprot.readI64();
23115 
        else:
23116 
          iprot.skip(ftype)
4875 varun.gupt 23117 
      else:
23118 
        iprot.skip(ftype)
23119 
      iprot.readFieldEnd()
23120 
    iprot.readStructEnd()
23121 
 
23122 
  def write(self, oprot):
23123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23125 
      return
5481 phani.kuma 23126 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 23127 
    if self.vendorId is not None:
23128 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23129 
      oprot.writeI64(self.vendorId)
23130 
      oprot.writeFieldEnd()
5481 phani.kuma 23131 
    if self.onlyVendorNotPaid is not None:
23132 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
23133 
      oprot.writeBool(self.onlyVendorNotPaid)
23134 
      oprot.writeFieldEnd()
23135 
    if self.billingDateFrom is not None:
23136 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
23137 
      oprot.writeI64(self.billingDateFrom)
23138 
      oprot.writeFieldEnd()
23139 
    if self.billingDateTo is not None:
23140 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
23141 
      oprot.writeI64(self.billingDateTo)
23142 
      oprot.writeFieldEnd()
4875 varun.gupt 23143 
    oprot.writeFieldStop()
23144 
    oprot.writeStructEnd()
23145 
 
23146 
  def validate(self):
23147 
    return
23148 
 
23149 
 
23150 
  def __repr__(self):
23151 
    L = ['%s=%r' % (key, value)
23152 
      for key, value in self.__dict__.iteritems()]
23153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23154 
 
23155 
  def __eq__(self, other):
23156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23157 
 
23158 
  def __ne__(self, other):
23159 
    return not (self == other)
23160 
 
5481 phani.kuma 23161 
class getBilledOrders_result:
4875 varun.gupt 23162 
  """
23163 
  Attributes:
23164 
   - success
23165 
   - ex
23166 
  """
23167 
 
23168 
  thrift_spec = (
23169 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23170 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23171 
  )
23172 
 
23173 
  def __init__(self, success=None, ex=None,):
23174 
    self.success = success
23175 
    self.ex = ex
23176 
 
23177 
  def read(self, iprot):
23178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23180 
      return
23181 
    iprot.readStructBegin()
23182 
    while True:
23183 
      (fname, ftype, fid) = iprot.readFieldBegin()
23184 
      if ftype == TType.STOP:
23185 
        break
23186 
      if fid == 0:
23187 
        if ftype == TType.LIST:
23188 
          self.success = []
5713 rajveer 23189 
          (_etype544, _size541) = iprot.readListBegin()
23190 
          for _i545 in xrange(_size541):
23191 
            _elem546 = Order()
23192 
            _elem546.read(iprot)
23193 
            self.success.append(_elem546)
4875 varun.gupt 23194 
          iprot.readListEnd()
23195 
        else:
23196 
          iprot.skip(ftype)
23197 
      elif fid == 1:
23198 
        if ftype == TType.STRUCT:
23199 
          self.ex = TransactionServiceException()
23200 
          self.ex.read(iprot)
23201 
        else:
23202 
          iprot.skip(ftype)
23203 
      else:
23204 
        iprot.skip(ftype)
23205 
      iprot.readFieldEnd()
23206 
    iprot.readStructEnd()
23207 
 
23208 
  def write(self, oprot):
23209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23211 
      return
5481 phani.kuma 23212 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 23213 
    if self.success is not None:
23214 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23215 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 23216 
      for iter547 in self.success:
23217 
        iter547.write(oprot)
4875 varun.gupt 23218 
      oprot.writeListEnd()
23219 
      oprot.writeFieldEnd()
23220 
    if self.ex is not None:
23221 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23222 
      self.ex.write(oprot)
23223 
      oprot.writeFieldEnd()
23224 
    oprot.writeFieldStop()
23225 
    oprot.writeStructEnd()
23226 
 
23227 
  def validate(self):
23228 
    return
23229 
 
23230 
 
23231 
  def __repr__(self):
23232 
    L = ['%s=%r' % (key, value)
23233 
      for key, value in self.__dict__.iteritems()]
23234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23235 
 
23236 
  def __eq__(self, other):
23237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23238 
 
23239 
  def __ne__(self, other):
23240 
    return not (self == other)
5031 varun.gupt 23241 
 
23242 
class getStatusDistributionOfOrders_args:
23243 
  """
23244 
  Attributes:
23245 
   - startDate
23246 
   - endDate
23247 
  """
23248 
 
23249 
  thrift_spec = (
23250 
    None, # 0
23251 
    (1, TType.I64, 'startDate', None, None, ), # 1
23252 
    (2, TType.I64, 'endDate', None, None, ), # 2
23253 
  )
23254 
 
23255 
  def __init__(self, startDate=None, endDate=None,):
23256 
    self.startDate = startDate
23257 
    self.endDate = endDate
23258 
 
23259 
  def read(self, iprot):
23260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23262 
      return
23263 
    iprot.readStructBegin()
23264 
    while True:
23265 
      (fname, ftype, fid) = iprot.readFieldBegin()
23266 
      if ftype == TType.STOP:
23267 
        break
23268 
      if fid == 1:
23269 
        if ftype == TType.I64:
23270 
          self.startDate = iprot.readI64();
23271 
        else:
23272 
          iprot.skip(ftype)
23273 
      elif fid == 2:
23274 
        if ftype == TType.I64:
23275 
          self.endDate = iprot.readI64();
23276 
        else:
23277 
          iprot.skip(ftype)
23278 
      else:
23279 
        iprot.skip(ftype)
23280 
      iprot.readFieldEnd()
23281 
    iprot.readStructEnd()
23282 
 
23283 
  def write(self, oprot):
23284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23286 
      return
23287 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
23288 
    if self.startDate is not None:
23289 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
23290 
      oprot.writeI64(self.startDate)
23291 
      oprot.writeFieldEnd()
23292 
    if self.endDate is not None:
23293 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
23294 
      oprot.writeI64(self.endDate)
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)
23313 
 
23314 
class getStatusDistributionOfOrders_result:
23315 
  """
23316 
  Attributes:
23317 
   - success
23318 
   - ex
23319 
  """
23320 
 
23321 
  thrift_spec = (
23322 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
23323 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23324 
  )
23325 
 
23326 
  def __init__(self, success=None, ex=None,):
23327 
    self.success = success
23328 
    self.ex = ex
23329 
 
23330 
  def read(self, iprot):
23331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23333 
      return
23334 
    iprot.readStructBegin()
23335 
    while True:
23336 
      (fname, ftype, fid) = iprot.readFieldBegin()
23337 
      if ftype == TType.STOP:
23338 
        break
23339 
      if fid == 0:
23340 
        if ftype == TType.MAP:
23341 
          self.success = {}
5713 rajveer 23342 
          (_ktype549, _vtype550, _size548 ) = iprot.readMapBegin()
23343 
          for _i552 in xrange(_size548):
23344 
            _key553 = iprot.readI64();
23345 
            _val554 = iprot.readI64();
23346 
            self.success[_key553] = _val554
5031 varun.gupt 23347 
          iprot.readMapEnd()
23348 
        else:
23349 
          iprot.skip(ftype)
23350 
      elif fid == 1:
23351 
        if ftype == TType.STRUCT:
23352 
          self.ex = TransactionServiceException()
23353 
          self.ex.read(iprot)
23354 
        else:
23355 
          iprot.skip(ftype)
23356 
      else:
23357 
        iprot.skip(ftype)
23358 
      iprot.readFieldEnd()
23359 
    iprot.readStructEnd()
23360 
 
23361 
  def write(self, oprot):
23362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23364 
      return
23365 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
23366 
    if self.success is not None:
23367 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23368 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5713 rajveer 23369 
      for kiter555,viter556 in self.success.items():
23370 
        oprot.writeI64(kiter555)
23371 
        oprot.writeI64(viter556)
5031 varun.gupt 23372 
      oprot.writeMapEnd()
23373 
      oprot.writeFieldEnd()
23374 
    if self.ex is not None:
23375 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23376 
      self.ex.write(oprot)
23377 
      oprot.writeFieldEnd()
23378 
    oprot.writeFieldStop()
23379 
    oprot.writeStructEnd()
23380 
 
23381 
  def validate(self):
23382 
    return
23383 
 
23384 
 
23385 
  def __repr__(self):
23386 
    L = ['%s=%r' % (key, value)
23387 
      for key, value in self.__dict__.iteritems()]
23388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23389 
 
23390 
  def __eq__(self, other):
23391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23392 
 
23393 
  def __ne__(self, other):
23394 
    return not (self == other)
5067 varun.gupt 23395 
 
23396 
class getOrderIdsForStatus_args:
23397 
  """
23398 
  Attributes:
23399 
   - status
23400 
   - startDatetime
23401 
   - endDatetime
23402 
  """
23403 
 
23404 
  thrift_spec = (
23405 
    None, # 0
23406 
    (1, TType.I64, 'status', None, None, ), # 1
23407 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
23408 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
23409 
  )
23410 
 
23411 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
23412 
    self.status = status
23413 
    self.startDatetime = startDatetime
23414 
    self.endDatetime = endDatetime
23415 
 
23416 
  def read(self, iprot):
23417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23419 
      return
23420 
    iprot.readStructBegin()
23421 
    while True:
23422 
      (fname, ftype, fid) = iprot.readFieldBegin()
23423 
      if ftype == TType.STOP:
23424 
        break
23425 
      if fid == 1:
23426 
        if ftype == TType.I64:
23427 
          self.status = iprot.readI64();
23428 
        else:
23429 
          iprot.skip(ftype)
23430 
      elif fid == 2:
23431 
        if ftype == TType.I64:
23432 
          self.startDatetime = iprot.readI64();
23433 
        else:
23434 
          iprot.skip(ftype)
23435 
      elif fid == 3:
23436 
        if ftype == TType.I64:
23437 
          self.endDatetime = iprot.readI64();
23438 
        else:
23439 
          iprot.skip(ftype)
23440 
      else:
23441 
        iprot.skip(ftype)
23442 
      iprot.readFieldEnd()
23443 
    iprot.readStructEnd()
23444 
 
23445 
  def write(self, oprot):
23446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23448 
      return
23449 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
23450 
    if self.status is not None:
23451 
      oprot.writeFieldBegin('status', TType.I64, 1)
23452 
      oprot.writeI64(self.status)
23453 
      oprot.writeFieldEnd()
23454 
    if self.startDatetime is not None:
23455 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
23456 
      oprot.writeI64(self.startDatetime)
23457 
      oprot.writeFieldEnd()
23458 
    if self.endDatetime is not None:
23459 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
23460 
      oprot.writeI64(self.endDatetime)
23461 
      oprot.writeFieldEnd()
23462 
    oprot.writeFieldStop()
23463 
    oprot.writeStructEnd()
23464 
 
23465 
  def validate(self):
23466 
    return
23467 
 
23468 
 
23469 
  def __repr__(self):
23470 
    L = ['%s=%r' % (key, value)
23471 
      for key, value in self.__dict__.iteritems()]
23472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23473 
 
23474 
  def __eq__(self, other):
23475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23476 
 
23477 
  def __ne__(self, other):
23478 
    return not (self == other)
23479 
 
23480 
class getOrderIdsForStatus_result:
23481 
  """
23482 
  Attributes:
23483 
   - success
23484 
   - ex
23485 
  """
23486 
 
23487 
  thrift_spec = (
23488 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23489 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23490 
  )
23491 
 
23492 
  def __init__(self, success=None, ex=None,):
23493 
    self.success = success
23494 
    self.ex = ex
23495 
 
23496 
  def read(self, iprot):
23497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23499 
      return
23500 
    iprot.readStructBegin()
23501 
    while True:
23502 
      (fname, ftype, fid) = iprot.readFieldBegin()
23503 
      if ftype == TType.STOP:
23504 
        break
23505 
      if fid == 0:
23506 
        if ftype == TType.LIST:
23507 
          self.success = []
5713 rajveer 23508 
          (_etype560, _size557) = iprot.readListBegin()
23509 
          for _i561 in xrange(_size557):
23510 
            _elem562 = iprot.readI64();
23511 
            self.success.append(_elem562)
5067 varun.gupt 23512 
          iprot.readListEnd()
23513 
        else:
23514 
          iprot.skip(ftype)
23515 
      elif fid == 1:
23516 
        if ftype == TType.STRUCT:
23517 
          self.ex = TransactionServiceException()
23518 
          self.ex.read(iprot)
23519 
        else:
23520 
          iprot.skip(ftype)
23521 
      else:
23522 
        iprot.skip(ftype)
23523 
      iprot.readFieldEnd()
23524 
    iprot.readStructEnd()
23525 
 
23526 
  def write(self, oprot):
23527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23529 
      return
23530 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
23531 
    if self.success is not None:
23532 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23533 
      oprot.writeListBegin(TType.I64, len(self.success))
5713 rajveer 23534 
      for iter563 in self.success:
23535 
        oprot.writeI64(iter563)
5067 varun.gupt 23536 
      oprot.writeListEnd()
23537 
      oprot.writeFieldEnd()
23538 
    if self.ex is not None:
23539 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23540 
      self.ex.write(oprot)
23541 
      oprot.writeFieldEnd()
23542 
    oprot.writeFieldStop()
23543 
    oprot.writeStructEnd()
23544 
 
23545 
  def validate(self):
23546 
    return
23547 
 
23548 
 
23549 
  def __repr__(self):
23550 
    L = ['%s=%r' % (key, value)
23551 
      for key, value in self.__dict__.iteritems()]
23552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23553 
 
23554 
  def __eq__(self, other):
23555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23556 
 
23557 
  def __ne__(self, other):
23558 
    return not (self == other)
5099 varun.gupt 23559 
 
5348 anupam.sin 23560 
class updateCODAgent_args:
23561 
  """
23562 
  Attributes:
23563 
   - agent
23564 
   - orderId
23565 
  """
23566 
 
23567 
  thrift_spec = (
23568 
    None, # 0
23569 
    (1, TType.STRING, 'agent', None, None, ), # 1
23570 
    (2, TType.I64, 'orderId', None, None, ), # 2
23571 
  )
23572 
 
23573 
  def __init__(self, agent=None, orderId=None,):
23574 
    self.agent = agent
23575 
    self.orderId = orderId
23576 
 
23577 
  def read(self, iprot):
23578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23580 
      return
23581 
    iprot.readStructBegin()
23582 
    while True:
23583 
      (fname, ftype, fid) = iprot.readFieldBegin()
23584 
      if ftype == TType.STOP:
23585 
        break
23586 
      if fid == 1:
23587 
        if ftype == TType.STRING:
23588 
          self.agent = iprot.readString();
23589 
        else:
23590 
          iprot.skip(ftype)
23591 
      elif fid == 2:
23592 
        if ftype == TType.I64:
23593 
          self.orderId = iprot.readI64();
23594 
        else:
23595 
          iprot.skip(ftype)
23596 
      else:
23597 
        iprot.skip(ftype)
23598 
      iprot.readFieldEnd()
23599 
    iprot.readStructEnd()
23600 
 
23601 
  def write(self, oprot):
23602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23604 
      return
23605 
    oprot.writeStructBegin('updateCODAgent_args')
23606 
    if self.agent is not None:
23607 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
23608 
      oprot.writeString(self.agent)
23609 
      oprot.writeFieldEnd()
23610 
    if self.orderId is not None:
23611 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
23612 
      oprot.writeI64(self.orderId)
23613 
      oprot.writeFieldEnd()
23614 
    oprot.writeFieldStop()
23615 
    oprot.writeStructEnd()
23616 
 
23617 
  def validate(self):
23618 
    return
23619 
 
23620 
 
23621 
  def __repr__(self):
23622 
    L = ['%s=%r' % (key, value)
23623 
      for key, value in self.__dict__.iteritems()]
23624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23625 
 
23626 
  def __eq__(self, other):
23627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23628 
 
23629 
  def __ne__(self, other):
23630 
    return not (self == other)
23631 
 
23632 
class updateCODAgent_result:
23633 
  """
23634 
  Attributes:
23635 
   - ex
23636 
  """
23637 
 
23638 
  thrift_spec = (
23639 
    None, # 0
23640 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23641 
  )
23642 
 
23643 
  def __init__(self, ex=None,):
23644 
    self.ex = ex
23645 
 
23646 
  def read(self, iprot):
23647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23649 
      return
23650 
    iprot.readStructBegin()
23651 
    while True:
23652 
      (fname, ftype, fid) = iprot.readFieldBegin()
23653 
      if ftype == TType.STOP:
23654 
        break
23655 
      if fid == 1:
23656 
        if ftype == TType.STRUCT:
23657 
          self.ex = TransactionServiceException()
23658 
          self.ex.read(iprot)
23659 
        else:
23660 
          iprot.skip(ftype)
23661 
      else:
23662 
        iprot.skip(ftype)
23663 
      iprot.readFieldEnd()
23664 
    iprot.readStructEnd()
23665 
 
23666 
  def write(self, oprot):
23667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23669 
      return
23670 
    oprot.writeStructBegin('updateCODAgent_result')
23671 
    if self.ex is not None:
23672 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23673 
      self.ex.write(oprot)
23674 
      oprot.writeFieldEnd()
23675 
    oprot.writeFieldStop()
23676 
    oprot.writeStructEnd()
23677 
 
23678 
  def validate(self):
23679 
    return
23680 
 
23681 
 
23682 
  def __repr__(self):
23683 
    L = ['%s=%r' % (key, value)
23684 
      for key, value in self.__dict__.iteritems()]
23685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23686 
 
23687 
  def __eq__(self, other):
23688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23689 
 
23690 
  def __ne__(self, other):
23691 
    return not (self == other)
23692 
 
5099 varun.gupt 23693 
class updateOrderAsPaidToVendor_args:
23694 
  """
23695 
  Attributes:
23696 
   - orderId
23697 
  """
23698 
 
23699 
  thrift_spec = (
23700 
    None, # 0
23701 
    (1, TType.I64, 'orderId', None, None, ), # 1
23702 
  )
23703 
 
23704 
  def __init__(self, orderId=None,):
23705 
    self.orderId = orderId
23706 
 
23707 
  def read(self, iprot):
23708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23710 
      return
23711 
    iprot.readStructBegin()
23712 
    while True:
23713 
      (fname, ftype, fid) = iprot.readFieldBegin()
23714 
      if ftype == TType.STOP:
23715 
        break
23716 
      if fid == 1:
23717 
        if ftype == TType.I64:
23718 
          self.orderId = iprot.readI64();
23719 
        else:
23720 
          iprot.skip(ftype)
23721 
      else:
23722 
        iprot.skip(ftype)
23723 
      iprot.readFieldEnd()
23724 
    iprot.readStructEnd()
23725 
 
23726 
  def write(self, oprot):
23727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23729 
      return
23730 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
23731 
    if self.orderId is not None:
23732 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23733 
      oprot.writeI64(self.orderId)
23734 
      oprot.writeFieldEnd()
23735 
    oprot.writeFieldStop()
23736 
    oprot.writeStructEnd()
23737 
 
23738 
  def validate(self):
23739 
    return
23740 
 
23741 
 
23742 
  def __repr__(self):
23743 
    L = ['%s=%r' % (key, value)
23744 
      for key, value in self.__dict__.iteritems()]
23745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23746 
 
23747 
  def __eq__(self, other):
23748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23749 
 
23750 
  def __ne__(self, other):
23751 
    return not (self == other)
23752 
 
23753 
class updateOrderAsPaidToVendor_result:
23754 
  """
23755 
  Attributes:
23756 
   - ex
23757 
  """
23758 
 
23759 
  thrift_spec = (
23760 
    None, # 0
23761 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23762 
  )
23763 
 
23764 
  def __init__(self, ex=None,):
23765 
    self.ex = ex
23766 
 
23767 
  def read(self, iprot):
23768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23770 
      return
23771 
    iprot.readStructBegin()
23772 
    while True:
23773 
      (fname, ftype, fid) = iprot.readFieldBegin()
23774 
      if ftype == TType.STOP:
23775 
        break
23776 
      if fid == 1:
23777 
        if ftype == TType.STRUCT:
23778 
          self.ex = TransactionServiceException()
23779 
          self.ex.read(iprot)
23780 
        else:
23781 
          iprot.skip(ftype)
23782 
      else:
23783 
        iprot.skip(ftype)
23784 
      iprot.readFieldEnd()
23785 
    iprot.readStructEnd()
23786 
 
23787 
  def write(self, oprot):
23788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23790 
      return
23791 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
23792 
    if self.ex is not None:
23793 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23794 
      self.ex.write(oprot)
23795 
      oprot.writeFieldEnd()
23796 
    oprot.writeFieldStop()
23797 
    oprot.writeStructEnd()
23798 
 
23799 
  def validate(self):
23800 
    return
23801 
 
23802 
 
23803 
  def __repr__(self):
23804 
    L = ['%s=%r' % (key, value)
23805 
      for key, value in self.__dict__.iteritems()]
23806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23807 
 
23808 
  def __eq__(self, other):
23809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23810 
 
23811 
  def __ne__(self, other):
23812 
    return not (self == other)
5208 varun.gupt 23813 
 
5386 phani.kuma 23814 
class updateOrderOnlyAsPaidToVendor_args:
23815 
  """
23816 
  Attributes:
23817 
   - orderId
23818 
  """
23819 
 
23820 
  thrift_spec = (
23821 
    None, # 0
23822 
    (1, TType.I64, 'orderId', None, None, ), # 1
23823 
  )
23824 
 
23825 
  def __init__(self, orderId=None,):
23826 
    self.orderId = orderId
23827 
 
23828 
  def read(self, iprot):
23829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23831 
      return
23832 
    iprot.readStructBegin()
23833 
    while True:
23834 
      (fname, ftype, fid) = iprot.readFieldBegin()
23835 
      if ftype == TType.STOP:
23836 
        break
23837 
      if fid == 1:
23838 
        if ftype == TType.I64:
23839 
          self.orderId = iprot.readI64();
23840 
        else:
23841 
          iprot.skip(ftype)
23842 
      else:
23843 
        iprot.skip(ftype)
23844 
      iprot.readFieldEnd()
23845 
    iprot.readStructEnd()
23846 
 
23847 
  def write(self, oprot):
23848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23850 
      return
23851 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
23852 
    if self.orderId is not None:
23853 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23854 
      oprot.writeI64(self.orderId)
23855 
      oprot.writeFieldEnd()
23856 
    oprot.writeFieldStop()
23857 
    oprot.writeStructEnd()
23858 
 
23859 
  def validate(self):
23860 
    return
23861 
 
23862 
 
23863 
  def __repr__(self):
23864 
    L = ['%s=%r' % (key, value)
23865 
      for key, value in self.__dict__.iteritems()]
23866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23867 
 
23868 
  def __eq__(self, other):
23869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23870 
 
23871 
  def __ne__(self, other):
23872 
    return not (self == other)
23873 
 
23874 
class updateOrderOnlyAsPaidToVendor_result:
23875 
  """
23876 
  Attributes:
23877 
   - ex
23878 
  """
23879 
 
23880 
  thrift_spec = (
23881 
    None, # 0
23882 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23883 
  )
23884 
 
23885 
  def __init__(self, ex=None,):
23886 
    self.ex = ex
23887 
 
23888 
  def read(self, iprot):
23889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23891 
      return
23892 
    iprot.readStructBegin()
23893 
    while True:
23894 
      (fname, ftype, fid) = iprot.readFieldBegin()
23895 
      if ftype == TType.STOP:
23896 
        break
23897 
      if fid == 1:
23898 
        if ftype == TType.STRUCT:
23899 
          self.ex = TransactionServiceException()
23900 
          self.ex.read(iprot)
23901 
        else:
23902 
          iprot.skip(ftype)
23903 
      else:
23904 
        iprot.skip(ftype)
23905 
      iprot.readFieldEnd()
23906 
    iprot.readStructEnd()
23907 
 
23908 
  def write(self, oprot):
23909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23911 
      return
23912 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
23913 
    if self.ex is not None:
23914 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23915 
      self.ex.write(oprot)
23916 
      oprot.writeFieldEnd()
23917 
    oprot.writeFieldStop()
23918 
    oprot.writeStructEnd()
23919 
 
23920 
  def validate(self):
23921 
    return
23922 
 
23923 
 
23924 
  def __repr__(self):
23925 
    L = ['%s=%r' % (key, value)
23926 
      for key, value in self.__dict__.iteritems()]
23927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23928 
 
23929 
  def __eq__(self, other):
23930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23931 
 
23932 
  def __ne__(self, other):
23933 
    return not (self == other)
23934 
 
5208 varun.gupt 23935 
class getRefundedOrdersMarkedPaid_args:
23936 
 
23937 
  thrift_spec = (
23938 
  )
23939 
 
23940 
  def read(self, iprot):
23941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23943 
      return
23944 
    iprot.readStructBegin()
23945 
    while True:
23946 
      (fname, ftype, fid) = iprot.readFieldBegin()
23947 
      if ftype == TType.STOP:
23948 
        break
23949 
      else:
23950 
        iprot.skip(ftype)
23951 
      iprot.readFieldEnd()
23952 
    iprot.readStructEnd()
23953 
 
23954 
  def write(self, oprot):
23955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23957 
      return
23958 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
23959 
    oprot.writeFieldStop()
23960 
    oprot.writeStructEnd()
23961 
 
23962 
  def validate(self):
23963 
    return
23964 
 
23965 
 
23966 
  def __repr__(self):
23967 
    L = ['%s=%r' % (key, value)
23968 
      for key, value in self.__dict__.iteritems()]
23969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23970 
 
23971 
  def __eq__(self, other):
23972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23973 
 
23974 
  def __ne__(self, other):
23975 
    return not (self == other)
23976 
 
23977 
class getRefundedOrdersMarkedPaid_result:
23978 
  """
23979 
  Attributes:
23980 
   - success
23981 
   - ex
23982 
  """
23983 
 
23984 
  thrift_spec = (
23985 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23986 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23987 
  )
23988 
 
23989 
  def __init__(self, success=None, ex=None,):
23990 
    self.success = success
23991 
    self.ex = ex
23992 
 
23993 
  def read(self, iprot):
23994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23996 
      return
23997 
    iprot.readStructBegin()
23998 
    while True:
23999 
      (fname, ftype, fid) = iprot.readFieldBegin()
24000 
      if ftype == TType.STOP:
24001 
        break
24002 
      if fid == 0:
24003 
        if ftype == TType.LIST:
24004 
          self.success = []
5713 rajveer 24005 
          (_etype567, _size564) = iprot.readListBegin()
24006 
          for _i568 in xrange(_size564):
24007 
            _elem569 = Order()
24008 
            _elem569.read(iprot)
24009 
            self.success.append(_elem569)
5208 varun.gupt 24010 
          iprot.readListEnd()
24011 
        else:
24012 
          iprot.skip(ftype)
24013 
      elif fid == 1:
24014 
        if ftype == TType.STRUCT:
24015 
          self.ex = TransactionServiceException()
24016 
          self.ex.read(iprot)
24017 
        else:
24018 
          iprot.skip(ftype)
24019 
      else:
24020 
        iprot.skip(ftype)
24021 
      iprot.readFieldEnd()
24022 
    iprot.readStructEnd()
24023 
 
24024 
  def write(self, oprot):
24025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24027 
      return
24028 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
24029 
    if self.success is not None:
24030 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24031 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 24032 
      for iter570 in self.success:
24033 
        iter570.write(oprot)
5208 varun.gupt 24034 
      oprot.writeListEnd()
24035 
      oprot.writeFieldEnd()
24036 
    if self.ex is not None:
24037 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24038 
      self.ex.write(oprot)
24039 
      oprot.writeFieldEnd()
24040 
    oprot.writeFieldStop()
24041 
    oprot.writeStructEnd()
24042 
 
24043 
  def validate(self):
24044 
    return
24045 
 
24046 
 
24047 
  def __repr__(self):
24048 
    L = ['%s=%r' % (key, value)
24049 
      for key, value in self.__dict__.iteritems()]
24050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24051 
 
24052 
  def __eq__(self, other):
24053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24054 
 
24055 
  def __ne__(self, other):
24056 
    return not (self == other)
5447 anupam.sin 24057 
 
24058 
class getAllVerificationAgents_args:
24059 
  """
24060 
  Attributes:
24061 
   - minOrderId
24062 
   - maxOrderId
24063 
  """
24064 
 
24065 
  thrift_spec = (
24066 
    None, # 0
24067 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
24068 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
24069 
  )
24070 
 
24071 
  def __init__(self, minOrderId=None, maxOrderId=None,):
24072 
    self.minOrderId = minOrderId
24073 
    self.maxOrderId = maxOrderId
24074 
 
24075 
  def read(self, iprot):
24076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24078 
      return
24079 
    iprot.readStructBegin()
24080 
    while True:
24081 
      (fname, ftype, fid) = iprot.readFieldBegin()
24082 
      if ftype == TType.STOP:
24083 
        break
24084 
      if fid == 1:
24085 
        if ftype == TType.I64:
24086 
          self.minOrderId = iprot.readI64();
24087 
        else:
24088 
          iprot.skip(ftype)
24089 
      elif fid == 2:
24090 
        if ftype == TType.I64:
24091 
          self.maxOrderId = iprot.readI64();
24092 
        else:
24093 
          iprot.skip(ftype)
24094 
      else:
24095 
        iprot.skip(ftype)
24096 
      iprot.readFieldEnd()
24097 
    iprot.readStructEnd()
24098 
 
24099 
  def write(self, oprot):
24100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24102 
      return
24103 
    oprot.writeStructBegin('getAllVerificationAgents_args')
24104 
    if self.minOrderId is not None:
24105 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
24106 
      oprot.writeI64(self.minOrderId)
24107 
      oprot.writeFieldEnd()
24108 
    if self.maxOrderId is not None:
24109 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
24110 
      oprot.writeI64(self.maxOrderId)
24111 
      oprot.writeFieldEnd()
24112 
    oprot.writeFieldStop()
24113 
    oprot.writeStructEnd()
24114 
 
24115 
  def validate(self):
24116 
    return
24117 
 
24118 
 
24119 
  def __repr__(self):
24120 
    L = ['%s=%r' % (key, value)
24121 
      for key, value in self.__dict__.iteritems()]
24122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24123 
 
24124 
  def __eq__(self, other):
24125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24126 
 
24127 
  def __ne__(self, other):
24128 
    return not (self == other)
24129 
 
24130 
class getAllVerificationAgents_result:
24131 
  """
24132 
  Attributes:
24133 
   - success
24134 
  """
24135 
 
24136 
  thrift_spec = (
24137 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
24138 
  )
24139 
 
24140 
  def __init__(self, success=None,):
24141 
    self.success = success
24142 
 
24143 
  def read(self, iprot):
24144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24146 
      return
24147 
    iprot.readStructBegin()
24148 
    while True:
24149 
      (fname, ftype, fid) = iprot.readFieldBegin()
24150 
      if ftype == TType.STOP:
24151 
        break
24152 
      if fid == 0:
24153 
        if ftype == TType.LIST:
24154 
          self.success = []
5713 rajveer 24155 
          (_etype574, _size571) = iprot.readListBegin()
24156 
          for _i575 in xrange(_size571):
24157 
            _elem576 = CODVerificationAgent()
24158 
            _elem576.read(iprot)
24159 
            self.success.append(_elem576)
5447 anupam.sin 24160 
          iprot.readListEnd()
24161 
        else:
24162 
          iprot.skip(ftype)
24163 
      else:
24164 
        iprot.skip(ftype)
24165 
      iprot.readFieldEnd()
24166 
    iprot.readStructEnd()
24167 
 
24168 
  def write(self, oprot):
24169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24171 
      return
24172 
    oprot.writeStructBegin('getAllVerificationAgents_result')
24173 
    if self.success is not None:
24174 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24175 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 24176 
      for iter577 in self.success:
24177 
        iter577.write(oprot)
5447 anupam.sin 24178 
      oprot.writeListEnd()
24179 
      oprot.writeFieldEnd()
24180 
    oprot.writeFieldStop()
24181 
    oprot.writeStructEnd()
24182 
 
24183 
  def validate(self):
24184 
    return
24185 
 
24186 
 
24187 
  def __repr__(self):
24188 
    L = ['%s=%r' % (key, value)
24189 
      for key, value in self.__dict__.iteritems()]
24190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24191 
 
24192 
  def __eq__(self, other):
24193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24194 
 
24195 
  def __ne__(self, other):
24196 
    return not (self == other)
5527 anupam.sin 24197 
 
24198 
class getAllAttributesForOrderId_args:
24199 
  """
24200 
  Attributes:
24201 
   - orderId
24202 
  """
24203 
 
24204 
  thrift_spec = (
24205 
    None, # 0
24206 
    (1, TType.I64, 'orderId', None, None, ), # 1
24207 
  )
24208 
 
24209 
  def __init__(self, orderId=None,):
24210 
    self.orderId = orderId
24211 
 
24212 
  def read(self, iprot):
24213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24215 
      return
24216 
    iprot.readStructBegin()
24217 
    while True:
24218 
      (fname, ftype, fid) = iprot.readFieldBegin()
24219 
      if ftype == TType.STOP:
24220 
        break
24221 
      if fid == 1:
24222 
        if ftype == TType.I64:
24223 
          self.orderId = iprot.readI64();
24224 
        else:
24225 
          iprot.skip(ftype)
24226 
      else:
24227 
        iprot.skip(ftype)
24228 
      iprot.readFieldEnd()
24229 
    iprot.readStructEnd()
24230 
 
24231 
  def write(self, oprot):
24232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24234 
      return
24235 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
24236 
    if self.orderId is not None:
24237 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24238 
      oprot.writeI64(self.orderId)
24239 
      oprot.writeFieldEnd()
24240 
    oprot.writeFieldStop()
24241 
    oprot.writeStructEnd()
24242 
 
24243 
  def validate(self):
24244 
    return
24245 
 
24246 
 
24247 
  def __repr__(self):
24248 
    L = ['%s=%r' % (key, value)
24249 
      for key, value in self.__dict__.iteritems()]
24250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24251 
 
24252 
  def __eq__(self, other):
24253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24254 
 
24255 
  def __ne__(self, other):
24256 
    return not (self == other)
24257 
 
24258 
class getAllAttributesForOrderId_result:
24259 
  """
24260 
  Attributes:
24261 
   - success
24262 
  """
24263 
 
24264 
  thrift_spec = (
24265 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
24266 
  )
24267 
 
24268 
  def __init__(self, success=None,):
24269 
    self.success = success
24270 
 
24271 
  def read(self, iprot):
24272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24274 
      return
24275 
    iprot.readStructBegin()
24276 
    while True:
24277 
      (fname, ftype, fid) = iprot.readFieldBegin()
24278 
      if ftype == TType.STOP:
24279 
        break
24280 
      if fid == 0:
24281 
        if ftype == TType.LIST:
24282 
          self.success = []
5713 rajveer 24283 
          (_etype581, _size578) = iprot.readListBegin()
24284 
          for _i582 in xrange(_size578):
24285 
            _elem583 = Attribute()
24286 
            _elem583.read(iprot)
24287 
            self.success.append(_elem583)
5527 anupam.sin 24288 
          iprot.readListEnd()
24289 
        else:
24290 
          iprot.skip(ftype)
24291 
      else:
24292 
        iprot.skip(ftype)
24293 
      iprot.readFieldEnd()
24294 
    iprot.readStructEnd()
24295 
 
24296 
  def write(self, oprot):
24297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24299 
      return
24300 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
24301 
    if self.success is not None:
24302 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24303 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 24304 
      for iter584 in self.success:
24305 
        iter584.write(oprot)
5527 anupam.sin 24306 
      oprot.writeListEnd()
24307 
      oprot.writeFieldEnd()
24308 
    oprot.writeFieldStop()
24309 
    oprot.writeStructEnd()
24310 
 
24311 
  def validate(self):
24312 
    return
24313 
 
24314 
 
24315 
  def __repr__(self):
24316 
    L = ['%s=%r' % (key, value)
24317 
      for key, value in self.__dict__.iteritems()]
24318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24319 
 
24320 
  def __eq__(self, other):
24321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24322 
 
24323 
  def __ne__(self, other):
24324 
    return not (self == other)
24325 
 
5676 rajveer 24326 
class setOrderAttributes_args:
24327 
  """
24328 
  Attributes:
24329 
   - orderId
24330 
   - attributes
24331 
  """
24332 
 
24333 
  thrift_spec = None
24334 
  def __init__(self, orderId=None, attributes=None,):
24335 
    self.orderId = orderId
24336 
    self.attributes = attributes
24337 
 
24338 
  def read(self, iprot):
24339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24341 
      return
24342 
    iprot.readStructBegin()
24343 
    while True:
24344 
      (fname, ftype, fid) = iprot.readFieldBegin()
24345 
      if ftype == TType.STOP:
24346 
        break
24347 
      if fid == 1:
24348 
        if ftype == TType.I64:
24349 
          self.orderId = iprot.readI64();
24350 
        else:
24351 
          iprot.skip(ftype)
24352 
      elif fid == -1:
24353 
        if ftype == TType.LIST:
24354 
          self.attributes = []
5713 rajveer 24355 
          (_etype588, _size585) = iprot.readListBegin()
24356 
          for _i589 in xrange(_size585):
24357 
            _elem590 = Attribute()
24358 
            _elem590.read(iprot)
24359 
            self.attributes.append(_elem590)
5676 rajveer 24360 
          iprot.readListEnd()
24361 
        else:
24362 
          iprot.skip(ftype)
24363 
      else:
24364 
        iprot.skip(ftype)
24365 
      iprot.readFieldEnd()
24366 
    iprot.readStructEnd()
24367 
 
24368 
  def write(self, oprot):
24369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24371 
      return
24372 
    oprot.writeStructBegin('setOrderAttributes_args')
24373 
    if self.attributes is not None:
24374 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
24375 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
5713 rajveer 24376 
      for iter591 in self.attributes:
24377 
        iter591.write(oprot)
5676 rajveer 24378 
      oprot.writeListEnd()
24379 
      oprot.writeFieldEnd()
24380 
    if self.orderId is not None:
24381 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24382 
      oprot.writeI64(self.orderId)
24383 
      oprot.writeFieldEnd()
24384 
    oprot.writeFieldStop()
24385 
    oprot.writeStructEnd()
24386 
 
24387 
  def validate(self):
24388 
    return
24389 
 
24390 
 
24391 
  def __repr__(self):
24392 
    L = ['%s=%r' % (key, value)
24393 
      for key, value in self.__dict__.iteritems()]
24394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24395 
 
24396 
  def __eq__(self, other):
24397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24398 
 
24399 
  def __ne__(self, other):
24400 
    return not (self == other)
24401 
 
24402 
class setOrderAttributes_result:
24403 
 
24404 
  thrift_spec = (
24405 
  )
24406 
 
24407 
  def read(self, iprot):
24408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24410 
      return
24411 
    iprot.readStructBegin()
24412 
    while True:
24413 
      (fname, ftype, fid) = iprot.readFieldBegin()
24414 
      if ftype == TType.STOP:
24415 
        break
24416 
      else:
24417 
        iprot.skip(ftype)
24418 
      iprot.readFieldEnd()
24419 
    iprot.readStructEnd()
24420 
 
24421 
  def write(self, oprot):
24422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24424 
      return
24425 
    oprot.writeStructBegin('setOrderAttributes_result')
24426 
    oprot.writeFieldStop()
24427 
    oprot.writeStructEnd()
24428 
 
24429 
  def validate(self):
24430 
    return
24431 
 
24432 
 
24433 
  def __repr__(self):
24434 
    L = ['%s=%r' % (key, value)
24435 
      for key, value in self.__dict__.iteritems()]
24436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24437 
 
24438 
  def __eq__(self, other):
24439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24440 
 
24441 
  def __ne__(self, other):
24442 
    return not (self == other)
24443 
 
5527 anupam.sin 24444 
class setOrderAttributeForTransaction_args:
24445 
  """
24446 
  Attributes:
24447 
   - transactionId
24448 
   - attribute
24449 
  """
24450 
 
24451 
  thrift_spec = None
24452 
  def __init__(self, transactionId=None, attribute=None,):
24453 
    self.transactionId = transactionId
24454 
    self.attribute = attribute
24455 
 
24456 
  def read(self, iprot):
24457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24459 
      return
24460 
    iprot.readStructBegin()
24461 
    while True:
24462 
      (fname, ftype, fid) = iprot.readFieldBegin()
24463 
      if ftype == TType.STOP:
24464 
        break
24465 
      if fid == 1:
24466 
        if ftype == TType.I64:
24467 
          self.transactionId = iprot.readI64();
24468 
        else:
24469 
          iprot.skip(ftype)
24470 
      elif fid == -1:
24471 
        if ftype == TType.STRUCT:
24472 
          self.attribute = Attribute()
24473 
          self.attribute.read(iprot)
24474 
        else:
24475 
          iprot.skip(ftype)
24476 
      else:
24477 
        iprot.skip(ftype)
24478 
      iprot.readFieldEnd()
24479 
    iprot.readStructEnd()
24480 
 
24481 
  def write(self, oprot):
24482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24484 
      return
24485 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
24486 
    if self.attribute is not None:
24487 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
24488 
      self.attribute.write(oprot)
24489 
      oprot.writeFieldEnd()
24490 
    if self.transactionId is not None:
24491 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
24492 
      oprot.writeI64(self.transactionId)
24493 
      oprot.writeFieldEnd()
24494 
    oprot.writeFieldStop()
24495 
    oprot.writeStructEnd()
24496 
 
24497 
  def validate(self):
24498 
    return
24499 
 
24500 
 
24501 
  def __repr__(self):
24502 
    L = ['%s=%r' % (key, value)
24503 
      for key, value in self.__dict__.iteritems()]
24504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24505 
 
24506 
  def __eq__(self, other):
24507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24508 
 
24509 
  def __ne__(self, other):
24510 
    return not (self == other)
24511 
 
24512 
class setOrderAttributeForTransaction_result:
24513 
 
24514 
  thrift_spec = (
24515 
  )
24516 
 
24517 
  def read(self, iprot):
24518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24520 
      return
24521 
    iprot.readStructBegin()
24522 
    while True:
24523 
      (fname, ftype, fid) = iprot.readFieldBegin()
24524 
      if ftype == TType.STOP:
24525 
        break
24526 
      else:
24527 
        iprot.skip(ftype)
24528 
      iprot.readFieldEnd()
24529 
    iprot.readStructEnd()
24530 
 
24531 
  def write(self, oprot):
24532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24534 
      return
24535 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
24536 
    oprot.writeFieldStop()
24537 
    oprot.writeStructEnd()
24538 
 
24539 
  def validate(self):
24540 
    return
24541 
 
24542 
 
24543 
  def __repr__(self):
24544 
    L = ['%s=%r' % (key, value)
24545 
      for key, value in self.__dict__.iteritems()]
24546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24547 
 
24548 
  def __eq__(self, other):
24549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24550 
 
24551 
  def __ne__(self, other):
24552 
    return not (self == other)
5553 rajveer 24553 
 
24554 
class getReceivePendingOrders_args:
24555 
  """
24556 
  Attributes:
24557 
   - storeId
24558 
  """
24559 
 
24560 
  thrift_spec = (
24561 
    None, # 0
24562 
    (1, TType.I64, 'storeId', None, None, ), # 1
24563 
  )
24564 
 
24565 
  def __init__(self, storeId=None,):
24566 
    self.storeId = storeId
24567 
 
24568 
  def read(self, iprot):
24569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24571 
      return
24572 
    iprot.readStructBegin()
24573 
    while True:
24574 
      (fname, ftype, fid) = iprot.readFieldBegin()
24575 
      if ftype == TType.STOP:
24576 
        break
24577 
      if fid == 1:
24578 
        if ftype == TType.I64:
24579 
          self.storeId = iprot.readI64();
24580 
        else:
24581 
          iprot.skip(ftype)
24582 
      else:
24583 
        iprot.skip(ftype)
24584 
      iprot.readFieldEnd()
24585 
    iprot.readStructEnd()
24586 
 
24587 
  def write(self, oprot):
24588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24590 
      return
24591 
    oprot.writeStructBegin('getReceivePendingOrders_args')
24592 
    if self.storeId is not None:
24593 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
24594 
      oprot.writeI64(self.storeId)
24595 
      oprot.writeFieldEnd()
24596 
    oprot.writeFieldStop()
24597 
    oprot.writeStructEnd()
24598 
 
24599 
  def validate(self):
24600 
    return
24601 
 
24602 
 
24603 
  def __repr__(self):
24604 
    L = ['%s=%r' % (key, value)
24605 
      for key, value in self.__dict__.iteritems()]
24606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24607 
 
24608 
  def __eq__(self, other):
24609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24610 
 
24611 
  def __ne__(self, other):
24612 
    return not (self == other)
24613 
 
24614 
class getReceivePendingOrders_result:
24615 
  """
24616 
  Attributes:
24617 
   - success
24618 
  """
24619 
 
24620 
  thrift_spec = (
24621 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24622 
  )
24623 
 
24624 
  def __init__(self, success=None,):
24625 
    self.success = success
24626 
 
24627 
  def read(self, iprot):
24628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24630 
      return
24631 
    iprot.readStructBegin()
24632 
    while True:
24633 
      (fname, ftype, fid) = iprot.readFieldBegin()
24634 
      if ftype == TType.STOP:
24635 
        break
24636 
      if fid == 0:
24637 
        if ftype == TType.LIST:
24638 
          self.success = []
5713 rajveer 24639 
          (_etype595, _size592) = iprot.readListBegin()
24640 
          for _i596 in xrange(_size592):
24641 
            _elem597 = Order()
24642 
            _elem597.read(iprot)
24643 
            self.success.append(_elem597)
5553 rajveer 24644 
          iprot.readListEnd()
24645 
        else:
24646 
          iprot.skip(ftype)
24647 
      else:
24648 
        iprot.skip(ftype)
24649 
      iprot.readFieldEnd()
24650 
    iprot.readStructEnd()
24651 
 
24652 
  def write(self, oprot):
24653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24655 
      return
24656 
    oprot.writeStructBegin('getReceivePendingOrders_result')
24657 
    if self.success is not None:
24658 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24659 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 24660 
      for iter598 in self.success:
24661 
        iter598.write(oprot)
5553 rajveer 24662 
      oprot.writeListEnd()
24663 
      oprot.writeFieldEnd()
24664 
    oprot.writeFieldStop()
24665 
    oprot.writeStructEnd()
24666 
 
24667 
  def validate(self):
24668 
    return
24669 
 
24670 
 
24671 
  def __repr__(self):
24672 
    L = ['%s=%r' % (key, value)
24673 
      for key, value in self.__dict__.iteritems()]
24674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24675 
 
24676 
  def __eq__(self, other):
24677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24678 
 
24679 
  def __ne__(self, other):
24680 
    return not (self == other)
24681 
 
24682 
class getReceivedAtStoreOrders_args:
24683 
  """
24684 
  Attributes:
24685 
   - storeId
24686 
  """
24687 
 
24688 
  thrift_spec = (
24689 
    None, # 0
24690 
    (1, TType.I64, 'storeId', None, None, ), # 1
24691 
  )
24692 
 
24693 
  def __init__(self, storeId=None,):
24694 
    self.storeId = storeId
24695 
 
24696 
  def read(self, iprot):
24697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24699 
      return
24700 
    iprot.readStructBegin()
24701 
    while True:
24702 
      (fname, ftype, fid) = iprot.readFieldBegin()
24703 
      if ftype == TType.STOP:
24704 
        break
24705 
      if fid == 1:
24706 
        if ftype == TType.I64:
24707 
          self.storeId = iprot.readI64();
24708 
        else:
24709 
          iprot.skip(ftype)
24710 
      else:
24711 
        iprot.skip(ftype)
24712 
      iprot.readFieldEnd()
24713 
    iprot.readStructEnd()
24714 
 
24715 
  def write(self, oprot):
24716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24718 
      return
24719 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
24720 
    if self.storeId is not None:
24721 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
24722 
      oprot.writeI64(self.storeId)
24723 
      oprot.writeFieldEnd()
24724 
    oprot.writeFieldStop()
24725 
    oprot.writeStructEnd()
24726 
 
24727 
  def validate(self):
24728 
    return
24729 
 
24730 
 
24731 
  def __repr__(self):
24732 
    L = ['%s=%r' % (key, value)
24733 
      for key, value in self.__dict__.iteritems()]
24734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24735 
 
24736 
  def __eq__(self, other):
24737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24738 
 
24739 
  def __ne__(self, other):
24740 
    return not (self == other)
24741 
 
24742 
class getReceivedAtStoreOrders_result:
24743 
  """
24744 
  Attributes:
24745 
   - success
24746 
  """
24747 
 
24748 
  thrift_spec = (
24749 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24750 
  )
24751 
 
24752 
  def __init__(self, success=None,):
24753 
    self.success = success
24754 
 
24755 
  def read(self, iprot):
24756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24758 
      return
24759 
    iprot.readStructBegin()
24760 
    while True:
24761 
      (fname, ftype, fid) = iprot.readFieldBegin()
24762 
      if ftype == TType.STOP:
24763 
        break
24764 
      if fid == 0:
24765 
        if ftype == TType.LIST:
24766 
          self.success = []
5713 rajveer 24767 
          (_etype602, _size599) = iprot.readListBegin()
24768 
          for _i603 in xrange(_size599):
24769 
            _elem604 = Order()
24770 
            _elem604.read(iprot)
24771 
            self.success.append(_elem604)
5553 rajveer 24772 
          iprot.readListEnd()
24773 
        else:
24774 
          iprot.skip(ftype)
24775 
      else:
24776 
        iprot.skip(ftype)
24777 
      iprot.readFieldEnd()
24778 
    iprot.readStructEnd()
24779 
 
24780 
  def write(self, oprot):
24781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24783 
      return
24784 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
24785 
    if self.success is not None:
24786 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24787 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 24788 
      for iter605 in self.success:
24789 
        iter605.write(oprot)
5553 rajveer 24790 
      oprot.writeListEnd()
24791 
      oprot.writeFieldEnd()
24792 
    oprot.writeFieldStop()
24793 
    oprot.writeStructEnd()
24794 
 
24795 
  def validate(self):
24796 
    return
24797 
 
24798 
 
24799 
  def __repr__(self):
24800 
    L = ['%s=%r' % (key, value)
24801 
      for key, value in self.__dict__.iteritems()]
24802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24803 
 
24804 
  def __eq__(self, other):
24805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24806 
 
24807 
  def __ne__(self, other):
24808 
    return not (self == other)
5593 mandeep.dh 24809 
 
5713 rajveer 24810 
class getOrdersCollectionAtStore_args:
24811 
  """
24812 
  Attributes:
24813 
   - storeId
24814 
   - fromDate
24815 
   - toDate
24816 
   - onlyCod
24817 
  """
24818 
 
24819 
  thrift_spec = (
24820 
    None, # 0
24821 
    (1, TType.I64, 'storeId', None, None, ), # 1
24822 
    (2, TType.I64, 'fromDate', None, None, ), # 2
24823 
    (3, TType.I64, 'toDate', None, None, ), # 3
24824 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
24825 
  )
24826 
 
24827 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
24828 
    self.storeId = storeId
24829 
    self.fromDate = fromDate
24830 
    self.toDate = toDate
24831 
    self.onlyCod = onlyCod
24832 
 
24833 
  def read(self, iprot):
24834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24836 
      return
24837 
    iprot.readStructBegin()
24838 
    while True:
24839 
      (fname, ftype, fid) = iprot.readFieldBegin()
24840 
      if ftype == TType.STOP:
24841 
        break
24842 
      if fid == 1:
24843 
        if ftype == TType.I64:
24844 
          self.storeId = iprot.readI64();
24845 
        else:
24846 
          iprot.skip(ftype)
24847 
      elif fid == 2:
24848 
        if ftype == TType.I64:
24849 
          self.fromDate = iprot.readI64();
24850 
        else:
24851 
          iprot.skip(ftype)
24852 
      elif fid == 3:
24853 
        if ftype == TType.I64:
24854 
          self.toDate = iprot.readI64();
24855 
        else:
24856 
          iprot.skip(ftype)
24857 
      elif fid == 4:
24858 
        if ftype == TType.BOOL:
24859 
          self.onlyCod = iprot.readBool();
24860 
        else:
24861 
          iprot.skip(ftype)
24862 
      else:
24863 
        iprot.skip(ftype)
24864 
      iprot.readFieldEnd()
24865 
    iprot.readStructEnd()
24866 
 
24867 
  def write(self, oprot):
24868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24870 
      return
24871 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
24872 
    if self.storeId is not None:
24873 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
24874 
      oprot.writeI64(self.storeId)
24875 
      oprot.writeFieldEnd()
24876 
    if self.fromDate is not None:
24877 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
24878 
      oprot.writeI64(self.fromDate)
24879 
      oprot.writeFieldEnd()
24880 
    if self.toDate is not None:
24881 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
24882 
      oprot.writeI64(self.toDate)
24883 
      oprot.writeFieldEnd()
24884 
    if self.onlyCod is not None:
24885 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
24886 
      oprot.writeBool(self.onlyCod)
24887 
      oprot.writeFieldEnd()
24888 
    oprot.writeFieldStop()
24889 
    oprot.writeStructEnd()
24890 
 
24891 
  def validate(self):
24892 
    return
24893 
 
24894 
 
24895 
  def __repr__(self):
24896 
    L = ['%s=%r' % (key, value)
24897 
      for key, value in self.__dict__.iteritems()]
24898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24899 
 
24900 
  def __eq__(self, other):
24901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24902 
 
24903 
  def __ne__(self, other):
24904 
    return not (self == other)
24905 
 
24906 
class getOrdersCollectionAtStore_result:
24907 
  """
24908 
  Attributes:
24909 
   - success
24910 
  """
24911 
 
24912 
  thrift_spec = (
24913 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24914 
  )
24915 
 
24916 
  def __init__(self, success=None,):
24917 
    self.success = success
24918 
 
24919 
  def read(self, iprot):
24920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24922 
      return
24923 
    iprot.readStructBegin()
24924 
    while True:
24925 
      (fname, ftype, fid) = iprot.readFieldBegin()
24926 
      if ftype == TType.STOP:
24927 
        break
24928 
      if fid == 0:
24929 
        if ftype == TType.LIST:
24930 
          self.success = []
24931 
          (_etype609, _size606) = iprot.readListBegin()
24932 
          for _i610 in xrange(_size606):
24933 
            _elem611 = Order()
24934 
            _elem611.read(iprot)
24935 
            self.success.append(_elem611)
24936 
          iprot.readListEnd()
24937 
        else:
24938 
          iprot.skip(ftype)
24939 
      else:
24940 
        iprot.skip(ftype)
24941 
      iprot.readFieldEnd()
24942 
    iprot.readStructEnd()
24943 
 
24944 
  def write(self, oprot):
24945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24947 
      return
24948 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
24949 
    if self.success is not None:
24950 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24951 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24952 
      for iter612 in self.success:
24953 
        iter612.write(oprot)
24954 
      oprot.writeListEnd()
24955 
      oprot.writeFieldEnd()
24956 
    oprot.writeFieldStop()
24957 
    oprot.writeStructEnd()
24958 
 
24959 
  def validate(self):
24960 
    return
24961 
 
24962 
 
24963 
  def __repr__(self):
24964 
    L = ['%s=%r' % (key, value)
24965 
      for key, value in self.__dict__.iteritems()]
24966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24967 
 
24968 
  def __eq__(self, other):
24969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24970 
 
24971 
  def __ne__(self, other):
24972 
    return not (self == other)
24973 
 
5833 rajveer 24974 
class getOrderAttributeValue_args:
24975 
  """
24976 
  Attributes:
24977 
   - orderId
24978 
   - attributeName
24979 
  """
24980 
 
24981 
  thrift_spec = None
24982 
  def __init__(self, orderId=None, attributeName=None,):
24983 
    self.orderId = orderId
24984 
    self.attributeName = attributeName
24985 
 
24986 
  def read(self, iprot):
24987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24989 
      return
24990 
    iprot.readStructBegin()
24991 
    while True:
24992 
      (fname, ftype, fid) = iprot.readFieldBegin()
24993 
      if ftype == TType.STOP:
24994 
        break
24995 
      if fid == 1:
24996 
        if ftype == TType.I64:
24997 
          self.orderId = iprot.readI64();
24998 
        else:
24999 
          iprot.skip(ftype)
25000 
      elif fid == -1:
25001 
        if ftype == TType.STRING:
25002 
          self.attributeName = iprot.readString();
25003 
        else:
25004 
          iprot.skip(ftype)
25005 
      else:
25006 
        iprot.skip(ftype)
25007 
      iprot.readFieldEnd()
25008 
    iprot.readStructEnd()
25009 
 
25010 
  def write(self, oprot):
25011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25013 
      return
25014 
    oprot.writeStructBegin('getOrderAttributeValue_args')
25015 
    if self.attributeName is not None:
25016 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
25017 
      oprot.writeString(self.attributeName)
25018 
      oprot.writeFieldEnd()
25019 
    if self.orderId is not None:
25020 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25021 
      oprot.writeI64(self.orderId)
25022 
      oprot.writeFieldEnd()
25023 
    oprot.writeFieldStop()
25024 
    oprot.writeStructEnd()
25025 
 
25026 
  def validate(self):
25027 
    return
25028 
 
25029 
 
25030 
  def __repr__(self):
25031 
    L = ['%s=%r' % (key, value)
25032 
      for key, value in self.__dict__.iteritems()]
25033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25034 
 
25035 
  def __eq__(self, other):
25036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25037 
 
25038 
  def __ne__(self, other):
25039 
    return not (self == other)
25040 
 
25041 
class getOrderAttributeValue_result:
25042 
  """
25043 
  Attributes:
25044 
   - success
25045 
  """
25046 
 
25047 
  thrift_spec = (
25048 
    (0, TType.STRING, 'success', None, None, ), # 0
25049 
  )
25050 
 
25051 
  def __init__(self, success=None,):
25052 
    self.success = success
25053 
 
25054 
  def read(self, iprot):
25055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25057 
      return
25058 
    iprot.readStructBegin()
25059 
    while True:
25060 
      (fname, ftype, fid) = iprot.readFieldBegin()
25061 
      if ftype == TType.STOP:
25062 
        break
25063 
      if fid == 0:
25064 
        if ftype == TType.STRING:
25065 
          self.success = iprot.readString();
25066 
        else:
25067 
          iprot.skip(ftype)
25068 
      else:
25069 
        iprot.skip(ftype)
25070 
      iprot.readFieldEnd()
25071 
    iprot.readStructEnd()
25072 
 
25073 
  def write(self, oprot):
25074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25076 
      return
25077 
    oprot.writeStructBegin('getOrderAttributeValue_result')
25078 
    if self.success is not None:
25079 
      oprot.writeFieldBegin('success', TType.STRING, 0)
25080 
      oprot.writeString(self.success)
25081 
      oprot.writeFieldEnd()
25082 
    oprot.writeFieldStop()
25083 
    oprot.writeStructEnd()
25084 
 
25085 
  def validate(self):
25086 
    return
25087 
 
25088 
 
25089 
  def __repr__(self):
25090 
    L = ['%s=%r' % (key, value)
25091 
      for key, value in self.__dict__.iteritems()]
25092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25093 
 
25094 
  def __eq__(self, other):
25095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25096 
 
25097 
  def __ne__(self, other):
25098 
    return not (self == other)
25099 
 
5593 mandeep.dh 25100 
class acceptOrderForItem_args:
25101 
  """
25102 
  Attributes:
25103 
   - itemId
25104 
   - quantity
25105 
   - fulfilmentWarehouseId
25106 
   - billingWarehouseId
25107 
  """
25108 
 
25109 
  thrift_spec = (
25110 
    None, # 0
25111 
    (1, TType.I64, 'itemId', None, None, ), # 1
25112 
    (2, TType.I64, 'quantity', None, None, ), # 2
25113 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
25114 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
25115 
  )
25116 
 
25117 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
25118 
    self.itemId = itemId
25119 
    self.quantity = quantity
25120 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
25121 
    self.billingWarehouseId = billingWarehouseId
25122 
 
25123 
  def read(self, iprot):
25124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25126 
      return
25127 
    iprot.readStructBegin()
25128 
    while True:
25129 
      (fname, ftype, fid) = iprot.readFieldBegin()
25130 
      if ftype == TType.STOP:
25131 
        break
25132 
      if fid == 1:
25133 
        if ftype == TType.I64:
25134 
          self.itemId = iprot.readI64();
25135 
        else:
25136 
          iprot.skip(ftype)
25137 
      elif fid == 2:
25138 
        if ftype == TType.I64:
25139 
          self.quantity = iprot.readI64();
25140 
        else:
25141 
          iprot.skip(ftype)
25142 
      elif fid == 3:
25143 
        if ftype == TType.I64:
25144 
          self.fulfilmentWarehouseId = iprot.readI64();
25145 
        else:
25146 
          iprot.skip(ftype)
25147 
      elif fid == 4:
25148 
        if ftype == TType.I64:
25149 
          self.billingWarehouseId = iprot.readI64();
25150 
        else:
25151 
          iprot.skip(ftype)
25152 
      else:
25153 
        iprot.skip(ftype)
25154 
      iprot.readFieldEnd()
25155 
    iprot.readStructEnd()
25156 
 
25157 
  def write(self, oprot):
25158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25160 
      return
25161 
    oprot.writeStructBegin('acceptOrderForItem_args')
25162 
    if self.itemId is not None:
25163 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
25164 
      oprot.writeI64(self.itemId)
25165 
      oprot.writeFieldEnd()
25166 
    if self.quantity is not None:
25167 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
25168 
      oprot.writeI64(self.quantity)
25169 
      oprot.writeFieldEnd()
25170 
    if self.fulfilmentWarehouseId is not None:
25171 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
25172 
      oprot.writeI64(self.fulfilmentWarehouseId)
25173 
      oprot.writeFieldEnd()
25174 
    if self.billingWarehouseId is not None:
25175 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
25176 
      oprot.writeI64(self.billingWarehouseId)
25177 
      oprot.writeFieldEnd()
25178 
    oprot.writeFieldStop()
25179 
    oprot.writeStructEnd()
25180 
 
25181 
  def validate(self):
25182 
    return
25183 
 
25184 
 
25185 
  def __repr__(self):
25186 
    L = ['%s=%r' % (key, value)
25187 
      for key, value in self.__dict__.iteritems()]
25188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25189 
 
25190 
  def __eq__(self, other):
25191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25192 
 
25193 
  def __ne__(self, other):
25194 
    return not (self == other)
25195 
 
25196 
class acceptOrderForItem_result:
25197 
 
25198 
  thrift_spec = (
25199 
  )
25200 
 
25201 
  def read(self, iprot):
25202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25204 
      return
25205 
    iprot.readStructBegin()
25206 
    while True:
25207 
      (fname, ftype, fid) = iprot.readFieldBegin()
25208 
      if ftype == TType.STOP:
25209 
        break
25210 
      else:
25211 
        iprot.skip(ftype)
25212 
      iprot.readFieldEnd()
25213 
    iprot.readStructEnd()
25214 
 
25215 
  def write(self, oprot):
25216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25218 
      return
25219 
    oprot.writeStructBegin('acceptOrderForItem_result')
25220 
    oprot.writeFieldStop()
25221 
    oprot.writeStructEnd()
25222 
 
25223 
  def validate(self):
25224 
    return
25225 
 
25226 
 
25227 
  def __repr__(self):
25228 
    L = ['%s=%r' % (key, value)
25229 
      for key, value in self.__dict__.iteritems()]
25230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25231 
 
25232 
  def __eq__(self, other):
25233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25234 
 
25235 
  def __ne__(self, other):
25236 
    return not (self == other)