Subversion Repositories SmartDukaan

Rev

Rev 5676 | Rev 5833 | 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 
 
5593 mandeep.dh 1253 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1254 
    """
1255 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1256 
    invoked while scanning IN of items.
5553 rajveer 1257 
 
5593 mandeep.dh 1258 
    Parameters:
1259 
     - itemId
1260 
     - quantity
1261 
     - fulfilmentWarehouseId
1262 
     - billingWarehouseId
1263 
    """
1264 
    pass
1265 
 
1266 
 
3376 rajveer 1267 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1268 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1269 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1270 
 
1271 
  def createTransaction(self, transaction):
1272 
    """
1273 
    Parameters:
1274 
     - transaction
1275 
    """
1276 
    self.send_createTransaction(transaction)
132 ashish 1277 
    return self.recv_createTransaction()
94 ashish 1278 
 
1279 
  def send_createTransaction(self, transaction):
1280 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1281 
    args = createTransaction_args()
1282 
    args.transaction = transaction
1283 
    args.write(self._oprot)
1284 
    self._oprot.writeMessageEnd()
1285 
    self._oprot.trans.flush()
1286 
 
1287 
  def recv_createTransaction(self, ):
1288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1289 
    if mtype == TMessageType.EXCEPTION:
1290 
      x = TApplicationException()
1291 
      x.read(self._iprot)
1292 
      self._iprot.readMessageEnd()
1293 
      raise x
1294 
    result = createTransaction_result()
1295 
    result.read(self._iprot)
1296 
    self._iprot.readMessageEnd()
3431 rajveer 1297 
    if result.success is not None:
132 ashish 1298 
      return result.success
3431 rajveer 1299 
    if result.ex is not None:
94 ashish 1300 
      raise result.ex
132 ashish 1301 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1302 
 
1303 
  def getTransaction(self, id):
1304 
    """
1305 
    Parameters:
1306 
     - id
1307 
    """
1308 
    self.send_getTransaction(id)
1309 
    return self.recv_getTransaction()
1310 
 
1311 
  def send_getTransaction(self, id):
1312 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1313 
    args = getTransaction_args()
1314 
    args.id = id
1315 
    args.write(self._oprot)
1316 
    self._oprot.writeMessageEnd()
1317 
    self._oprot.trans.flush()
1318 
 
1319 
  def recv_getTransaction(self, ):
1320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1321 
    if mtype == TMessageType.EXCEPTION:
1322 
      x = TApplicationException()
1323 
      x.read(self._iprot)
1324 
      self._iprot.readMessageEnd()
1325 
      raise x
1326 
    result = getTransaction_result()
1327 
    result.read(self._iprot)
1328 
    self._iprot.readMessageEnd()
3431 rajveer 1329 
    if result.success is not None:
94 ashish 1330 
      return result.success
3431 rajveer 1331 
    if result.ex is not None:
94 ashish 1332 
      raise result.ex
1333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1334 
 
1335 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1336 
    """
1337 
    Parameters:
1338 
     - customerId
1339 
     - from_date
1340 
     - to_date
1341 
     - status
1342 
    """
1343 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1344 
    return self.recv_getTransactionsForCustomer()
1345 
 
1346 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1347 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1348 
    args = getTransactionsForCustomer_args()
1349 
    args.customerId = customerId
1350 
    args.from_date = from_date
1351 
    args.to_date = to_date
1352 
    args.status = status
1353 
    args.write(self._oprot)
1354 
    self._oprot.writeMessageEnd()
1355 
    self._oprot.trans.flush()
1356 
 
1357 
  def recv_getTransactionsForCustomer(self, ):
1358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1359 
    if mtype == TMessageType.EXCEPTION:
1360 
      x = TApplicationException()
1361 
      x.read(self._iprot)
1362 
      self._iprot.readMessageEnd()
1363 
      raise x
1364 
    result = getTransactionsForCustomer_result()
1365 
    result.read(self._iprot)
1366 
    self._iprot.readMessageEnd()
3431 rajveer 1367 
    if result.success is not None:
94 ashish 1368 
      return result.success
3431 rajveer 1369 
    if result.ex is not None:
94 ashish 1370 
      raise result.ex
1371 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1372 
 
132 ashish 1373 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1374 
    """
1375 
    Parameters:
1376 
     - shoppingCartId
1377 
    """
1378 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1379 
    return self.recv_getTransactionsForShoppingCartId()
1380 
 
1381 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1382 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1383 
    args = getTransactionsForShoppingCartId_args()
1384 
    args.shoppingCartId = shoppingCartId
1385 
    args.write(self._oprot)
1386 
    self._oprot.writeMessageEnd()
1387 
    self._oprot.trans.flush()
1388 
 
1389 
  def recv_getTransactionsForShoppingCartId(self, ):
1390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1391 
    if mtype == TMessageType.EXCEPTION:
1392 
      x = TApplicationException()
1393 
      x.read(self._iprot)
1394 
      self._iprot.readMessageEnd()
1395 
      raise x
1396 
    result = getTransactionsForShoppingCartId_result()
1397 
    result.read(self._iprot)
1398 
    self._iprot.readMessageEnd()
3431 rajveer 1399 
    if result.success is not None:
132 ashish 1400 
      return result.success
3431 rajveer 1401 
    if result.ex is not None:
132 ashish 1402 
      raise result.ex
1403 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1404 
 
94 ashish 1405 
  def getTransactionStatus(self, transactionId):
1406 
    """
1407 
    Parameters:
1408 
     - transactionId
1409 
    """
1410 
    self.send_getTransactionStatus(transactionId)
1411 
    return self.recv_getTransactionStatus()
1412 
 
1413 
  def send_getTransactionStatus(self, transactionId):
1414 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1415 
    args = getTransactionStatus_args()
1416 
    args.transactionId = transactionId
1417 
    args.write(self._oprot)
1418 
    self._oprot.writeMessageEnd()
1419 
    self._oprot.trans.flush()
1420 
 
1421 
  def recv_getTransactionStatus(self, ):
1422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1423 
    if mtype == TMessageType.EXCEPTION:
1424 
      x = TApplicationException()
1425 
      x.read(self._iprot)
1426 
      self._iprot.readMessageEnd()
1427 
      raise x
1428 
    result = getTransactionStatus_result()
1429 
    result.read(self._iprot)
1430 
    self._iprot.readMessageEnd()
3431 rajveer 1431 
    if result.success is not None:
94 ashish 1432 
      return result.success
3431 rajveer 1433 
    if result.ex is not None:
94 ashish 1434 
      raise result.ex
1435 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1436 
 
5527 anupam.sin 1437 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1438 
    """
1439 
    Parameters:
1440 
     - transactionId
1441 
     - status
1442 
     - description
5527 anupam.sin 1443 
     - pickUp
1444 
     - orderType
94 ashish 1445 
    """
5527 anupam.sin 1446 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1447 
    return self.recv_changeTransactionStatus()
1448 
 
5527 anupam.sin 1449 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1450 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1451 
    args = changeTransactionStatus_args()
1452 
    args.transactionId = transactionId
1453 
    args.status = status
1454 
    args.description = description
5527 anupam.sin 1455 
    args.pickUp = pickUp
1456 
    args.orderType = orderType
94 ashish 1457 
    args.write(self._oprot)
1458 
    self._oprot.writeMessageEnd()
1459 
    self._oprot.trans.flush()
1460 
 
1461 
  def recv_changeTransactionStatus(self, ):
1462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1463 
    if mtype == TMessageType.EXCEPTION:
1464 
      x = TApplicationException()
1465 
      x.read(self._iprot)
1466 
      self._iprot.readMessageEnd()
1467 
      raise x
1468 
    result = changeTransactionStatus_result()
1469 
    result.read(self._iprot)
1470 
    self._iprot.readMessageEnd()
3431 rajveer 1471 
    if result.success is not None:
94 ashish 1472 
      return result.success
3431 rajveer 1473 
    if result.ex is not None:
94 ashish 1474 
      raise result.ex
1475 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1476 
 
1398 varun.gupt 1477 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1478 
    """
1479 
    Parameters:
1480 
     - transactionId
1481 
    """
1398 varun.gupt 1482 
    self.send_enqueueTransactionInfoEmail(transactionId)
1483 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1484 
 
1398 varun.gupt 1485 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1486 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1487 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1488 
    args.transactionId = transactionId
1489 
    args.write(self._oprot)
1490 
    self._oprot.writeMessageEnd()
1491 
    self._oprot.trans.flush()
1492 
 
1398 varun.gupt 1493 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1495 
    if mtype == TMessageType.EXCEPTION:
1496 
      x = TApplicationException()
1497 
      x.read(self._iprot)
1498 
      self._iprot.readMessageEnd()
1499 
      raise x
1398 varun.gupt 1500 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1501 
    result.read(self._iprot)
1502 
    self._iprot.readMessageEnd()
3431 rajveer 1503 
    if result.success is not None:
1382 varun.gupt 1504 
      return result.success
3431 rajveer 1505 
    if result.ex is not None:
1382 varun.gupt 1506 
      raise result.ex
1398 varun.gupt 1507 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1508 
 
4801 anupam.sin 1509 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1510 
    """
1511 
    Parameters:
4801 anupam.sin 1512 
     - statuses
483 rajveer 1513 
     - from_date
1514 
     - to_date
1515 
     - warehouse_id
94 ashish 1516 
    """
4801 anupam.sin 1517 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1518 
    return self.recv_getAllOrders()
94 ashish 1519 
 
4801 anupam.sin 1520 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1521 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1522 
    args = getAllOrders_args()
4801 anupam.sin 1523 
    args.statuses = statuses
483 rajveer 1524 
    args.from_date = from_date
1525 
    args.to_date = to_date
1526 
    args.warehouse_id = warehouse_id
94 ashish 1527 
    args.write(self._oprot)
1528 
    self._oprot.writeMessageEnd()
1529 
    self._oprot.trans.flush()
1530 
 
483 rajveer 1531 
  def recv_getAllOrders(self, ):
94 ashish 1532 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1533 
    if mtype == TMessageType.EXCEPTION:
1534 
      x = TApplicationException()
1535 
      x.read(self._iprot)
1536 
      self._iprot.readMessageEnd()
1537 
      raise x
483 rajveer 1538 
    result = getAllOrders_result()
94 ashish 1539 
    result.read(self._iprot)
1540 
    self._iprot.readMessageEnd()
3431 rajveer 1541 
    if result.success is not None:
94 ashish 1542 
      return result.success
3431 rajveer 1543 
    if result.ex is not None:
94 ashish 1544 
      raise result.ex
483 rajveer 1545 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1546 
 
4133 chandransh 1547 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1548 
    """
1549 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1550 
    Pass the status as null and the limit as 0 to ignore them.
1551 
 
1552 
    Parameters:
1553 
     - statuses
1554 
     - offset
1555 
     - limit
1556 
     - warehouse_id
1557 
    """
1558 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1559 
    return self.recv_getOrdersInBatch()
1560 
 
1561 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1562 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1563 
    args = getOrdersInBatch_args()
1564 
    args.statuses = statuses
1565 
    args.offset = offset
1566 
    args.limit = limit
1567 
    args.warehouse_id = warehouse_id
1568 
    args.write(self._oprot)
1569 
    self._oprot.writeMessageEnd()
1570 
    self._oprot.trans.flush()
1571 
 
1572 
  def recv_getOrdersInBatch(self, ):
1573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1574 
    if mtype == TMessageType.EXCEPTION:
1575 
      x = TApplicationException()
1576 
      x.read(self._iprot)
1577 
      self._iprot.readMessageEnd()
1578 
      raise x
1579 
    result = getOrdersInBatch_result()
1580 
    result.read(self._iprot)
1581 
    self._iprot.readMessageEnd()
1582 
    if result.success is not None:
1583 
      return result.success
1584 
    if result.ex is not None:
1585 
      raise result.ex
1586 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1587 
 
1588 
  def getOrderCount(self, statuses, warehouseId):
1589 
    """
1590 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1591 
 
1592 
    Parameters:
1593 
     - statuses
1594 
     - warehouseId
1595 
    """
1596 
    self.send_getOrderCount(statuses, warehouseId)
1597 
    return self.recv_getOrderCount()
1598 
 
1599 
  def send_getOrderCount(self, statuses, warehouseId):
1600 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1601 
    args = getOrderCount_args()
1602 
    args.statuses = statuses
1603 
    args.warehouseId = warehouseId
1604 
    args.write(self._oprot)
1605 
    self._oprot.writeMessageEnd()
1606 
    self._oprot.trans.flush()
1607 
 
1608 
  def recv_getOrderCount(self, ):
1609 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1610 
    if mtype == TMessageType.EXCEPTION:
1611 
      x = TApplicationException()
1612 
      x.read(self._iprot)
1613 
      self._iprot.readMessageEnd()
1614 
      raise x
1615 
    result = getOrderCount_result()
1616 
    result.read(self._iprot)
1617 
    self._iprot.readMessageEnd()
1618 
    if result.success is not None:
1619 
      return result.success
1620 
    if result.ex is not None:
1621 
      raise result.ex
1622 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1623 
 
999 varun.gupt 1624 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1625 
    """
1132 chandransh 1626 
    Returns orders within a range of their billing dates
3431 rajveer 1627 
 
999 varun.gupt 1628 
    Parameters:
1629 
     - status
1630 
     - start_billing_date
1631 
     - end_billing_date
1632 
     - warehouse_id
1633 
    """
1634 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1635 
    return self.recv_getOrdersByBillingDate()
1636 
 
1637 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1638 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1639 
    args = getOrdersByBillingDate_args()
1640 
    args.status = status
1641 
    args.start_billing_date = start_billing_date
1642 
    args.end_billing_date = end_billing_date
1643 
    args.warehouse_id = warehouse_id
1644 
    args.write(self._oprot)
1645 
    self._oprot.writeMessageEnd()
1646 
    self._oprot.trans.flush()
1647 
 
1648 
  def recv_getOrdersByBillingDate(self, ):
1649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1650 
    if mtype == TMessageType.EXCEPTION:
1651 
      x = TApplicationException()
1652 
      x.read(self._iprot)
1653 
      self._iprot.readMessageEnd()
1654 
      raise x
1655 
    result = getOrdersByBillingDate_result()
1656 
    result.read(self._iprot)
1657 
    self._iprot.readMessageEnd()
3431 rajveer 1658 
    if result.success is not None:
999 varun.gupt 1659 
      return result.success
3431 rajveer 1660 
    if result.ex is not None:
999 varun.gupt 1661 
      raise result.ex
1662 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1663 
 
3451 chandransh 1664 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1665 
    """
1666 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1667 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1668 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1669 
 
3427 chandransh 1670 
    Parameters:
1671 
     - fromShippingDate
1672 
     - toShippingDate
1673 
     - providerId
1674 
     - warehouseId
3451 chandransh 1675 
     - cod
3427 chandransh 1676 
    """
3451 chandransh 1677 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1678 
    return self.recv_getOrdersByShippingDate()
1679 
 
3451 chandransh 1680 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1681 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1682 
    args = getOrdersByShippingDate_args()
1683 
    args.fromShippingDate = fromShippingDate
1684 
    args.toShippingDate = toShippingDate
1685 
    args.providerId = providerId
1686 
    args.warehouseId = warehouseId
3451 chandransh 1687 
    args.cod = cod
3427 chandransh 1688 
    args.write(self._oprot)
1689 
    self._oprot.writeMessageEnd()
1690 
    self._oprot.trans.flush()
1691 
 
1692 
  def recv_getOrdersByShippingDate(self, ):
1693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1694 
    if mtype == TMessageType.EXCEPTION:
1695 
      x = TApplicationException()
1696 
      x.read(self._iprot)
1697 
      self._iprot.readMessageEnd()
1698 
      raise x
1699 
    result = getOrdersByShippingDate_result()
1700 
    result.read(self._iprot)
1701 
    self._iprot.readMessageEnd()
3431 rajveer 1702 
    if result.success is not None:
3427 chandransh 1703 
      return result.success
3431 rajveer 1704 
    if result.ex is not None:
3427 chandransh 1705 
      raise result.ex
1706 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1707 
 
1382 varun.gupt 1708 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1709 
    """
1710 
    Returns order ids for orders which can be returned
3431 rajveer 1711 
 
1382 varun.gupt 1712 
    Parameters:
1713 
     - customer_id
1714 
     - limit
1715 
    """
1716 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1717 
    return self.recv_getReturnableOrdersForCustomer()
1718 
 
1719 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1720 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1721 
    args = getReturnableOrdersForCustomer_args()
1722 
    args.customer_id = customer_id
1723 
    args.limit = limit
1724 
    args.write(self._oprot)
1725 
    self._oprot.writeMessageEnd()
1726 
    self._oprot.trans.flush()
1727 
 
1728 
  def recv_getReturnableOrdersForCustomer(self, ):
1729 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1730 
    if mtype == TMessageType.EXCEPTION:
1731 
      x = TApplicationException()
1732 
      x.read(self._iprot)
1733 
      self._iprot.readMessageEnd()
1734 
      raise x
1735 
    result = getReturnableOrdersForCustomer_result()
1736 
    result.read(self._iprot)
1737 
    self._iprot.readMessageEnd()
3431 rajveer 1738 
    if result.success is not None:
1382 varun.gupt 1739 
      return result.success
3431 rajveer 1740 
    if result.ex is not None:
1382 varun.gupt 1741 
      raise result.ex
1742 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1743 
 
1744 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1745 
    """
1746 
    Returns order ids for orders which can be cancelled
3431 rajveer 1747 
 
1382 varun.gupt 1748 
    Parameters:
1749 
     - customer_id
1750 
     - limit
1751 
    """
1752 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1753 
    return self.recv_getCancellableOrdersForCustomer()
1754 
 
1755 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1756 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1757 
    args = getCancellableOrdersForCustomer_args()
1758 
    args.customer_id = customer_id
1759 
    args.limit = limit
1760 
    args.write(self._oprot)
1761 
    self._oprot.writeMessageEnd()
1762 
    self._oprot.trans.flush()
1763 
 
1764 
  def recv_getCancellableOrdersForCustomer(self, ):
1765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1766 
    if mtype == TMessageType.EXCEPTION:
1767 
      x = TApplicationException()
1768 
      x.read(self._iprot)
1769 
      self._iprot.readMessageEnd()
1770 
      raise x
1771 
    result = getCancellableOrdersForCustomer_result()
1772 
    result.read(self._iprot)
1773 
    self._iprot.readMessageEnd()
3431 rajveer 1774 
    if result.success is not None:
1382 varun.gupt 1775 
      return result.success
3431 rajveer 1776 
    if result.ex is not None:
1382 varun.gupt 1777 
      raise result.ex
1778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1779 
 
483 rajveer 1780 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1781 
    """
1782 
    Parameters:
483 rajveer 1783 
     - orderId
1784 
     - status
1785 
     - description
94 ashish 1786 
    """
483 rajveer 1787 
    self.send_changeOrderStatus(orderId, status, description)
1788 
    return self.recv_changeOrderStatus()
94 ashish 1789 
 
483 rajveer 1790 
  def send_changeOrderStatus(self, orderId, status, description):
1791 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1792 
    args = changeOrderStatus_args()
1793 
    args.orderId = orderId
1794 
    args.status = status
1795 
    args.description = description
94 ashish 1796 
    args.write(self._oprot)
1797 
    self._oprot.writeMessageEnd()
1798 
    self._oprot.trans.flush()
1799 
 
483 rajveer 1800 
  def recv_changeOrderStatus(self, ):
94 ashish 1801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1802 
    if mtype == TMessageType.EXCEPTION:
1803 
      x = TApplicationException()
1804 
      x.read(self._iprot)
1805 
      self._iprot.readMessageEnd()
1806 
      raise x
483 rajveer 1807 
    result = changeOrderStatus_result()
94 ashish 1808 
    result.read(self._iprot)
1809 
    self._iprot.readMessageEnd()
3431 rajveer 1810 
    if result.success is not None:
94 ashish 1811 
      return result.success
3431 rajveer 1812 
    if result.ex is not None:
94 ashish 1813 
      raise result.ex
483 rajveer 1814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1815 
 
1528 ankur.sing 1816 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1817 
    """
1528 ankur.sing 1818 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1819 
    only user who owns the transaction can view its order details.
3431 rajveer 1820 
 
94 ashish 1821 
    Parameters:
1822 
     - transactionId
1528 ankur.sing 1823 
     - customerId
94 ashish 1824 
    """
1528 ankur.sing 1825 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1826 
    return self.recv_getOrdersForTransaction()
94 ashish 1827 
 
1528 ankur.sing 1828 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1829 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1830 
    args = getOrdersForTransaction_args()
94 ashish 1831 
    args.transactionId = transactionId
1528 ankur.sing 1832 
    args.customerId = customerId
94 ashish 1833 
    args.write(self._oprot)
1834 
    self._oprot.writeMessageEnd()
1835 
    self._oprot.trans.flush()
1836 
 
483 rajveer 1837 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1839 
    if mtype == TMessageType.EXCEPTION:
1840 
      x = TApplicationException()
1841 
      x.read(self._iprot)
1842 
      self._iprot.readMessageEnd()
1843 
      raise x
483 rajveer 1844 
    result = getOrdersForTransaction_result()
94 ashish 1845 
    result.read(self._iprot)
1846 
    self._iprot.readMessageEnd()
3431 rajveer 1847 
    if result.success is not None:
94 ashish 1848 
      return result.success
3431 rajveer 1849 
    if result.ex is not None:
94 ashish 1850 
      raise result.ex
483 rajveer 1851 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1852 
 
3014 chandransh 1853 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1854 
    """
3014 chandransh 1855 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1856 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1857 
 
94 ashish 1858 
    Parameters:
483 rajveer 1859 
     - customerId
1860 
     - from_date
1861 
     - to_date
3014 chandransh 1862 
     - statuses
94 ashish 1863 
    """
3014 chandransh 1864 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1865 
    return self.recv_getOrdersForCustomer()
94 ashish 1866 
 
3014 chandransh 1867 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1868 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1869 
    args = getOrdersForCustomer_args()
1870 
    args.customerId = customerId
1871 
    args.from_date = from_date
1872 
    args.to_date = to_date
3014 chandransh 1873 
    args.statuses = statuses
94 ashish 1874 
    args.write(self._oprot)
1875 
    self._oprot.writeMessageEnd()
1876 
    self._oprot.trans.flush()
1877 
 
483 rajveer 1878 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1880 
    if mtype == TMessageType.EXCEPTION:
1881 
      x = TApplicationException()
1882 
      x.read(self._iprot)
1883 
      self._iprot.readMessageEnd()
1884 
      raise x
483 rajveer 1885 
    result = getOrdersForCustomer_result()
94 ashish 1886 
    result.read(self._iprot)
1887 
    self._iprot.readMessageEnd()
3431 rajveer 1888 
    if result.success is not None:
94 ashish 1889 
      return result.success
3431 rajveer 1890 
    if result.ex is not None:
94 ashish 1891 
      raise result.ex
483 rajveer 1892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1893 
 
483 rajveer 1894 
  def createOrder(self, order):
94 ashish 1895 
    """
1896 
    Parameters:
483 rajveer 1897 
     - order
94 ashish 1898 
    """
483 rajveer 1899 
    self.send_createOrder(order)
1900 
    return self.recv_createOrder()
94 ashish 1901 
 
483 rajveer 1902 
  def send_createOrder(self, order):
1903 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1904 
    args = createOrder_args()
1905 
    args.order = order
94 ashish 1906 
    args.write(self._oprot)
1907 
    self._oprot.writeMessageEnd()
1908 
    self._oprot.trans.flush()
1909 
 
483 rajveer 1910 
  def recv_createOrder(self, ):
94 ashish 1911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1912 
    if mtype == TMessageType.EXCEPTION:
1913 
      x = TApplicationException()
1914 
      x.read(self._iprot)
1915 
      self._iprot.readMessageEnd()
1916 
      raise x
483 rajveer 1917 
    result = createOrder_result()
94 ashish 1918 
    result.read(self._iprot)
1919 
    self._iprot.readMessageEnd()
3431 rajveer 1920 
    if result.success is not None:
94 ashish 1921 
      return result.success
3431 rajveer 1922 
    if result.ex is not None:
94 ashish 1923 
      raise result.ex
483 rajveer 1924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1925 
 
483 rajveer 1926 
  def getOrder(self, id):
94 ashish 1927 
    """
1928 
    Parameters:
483 rajveer 1929 
     - id
94 ashish 1930 
    """
483 rajveer 1931 
    self.send_getOrder(id)
1932 
    return self.recv_getOrder()
94 ashish 1933 
 
483 rajveer 1934 
  def send_getOrder(self, id):
1935 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1936 
    args = getOrder_args()
1937 
    args.id = id
94 ashish 1938 
    args.write(self._oprot)
1939 
    self._oprot.writeMessageEnd()
1940 
    self._oprot.trans.flush()
1941 
 
483 rajveer 1942 
  def recv_getOrder(self, ):
94 ashish 1943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1944 
    if mtype == TMessageType.EXCEPTION:
1945 
      x = TApplicationException()
1946 
      x.read(self._iprot)
1947 
      self._iprot.readMessageEnd()
1948 
      raise x
483 rajveer 1949 
    result = getOrder_result()
94 ashish 1950 
    result.read(self._iprot)
1951 
    self._iprot.readMessageEnd()
3431 rajveer 1952 
    if result.success is not None:
94 ashish 1953 
      return result.success
3431 rajveer 1954 
    if result.ex is not None:
94 ashish 1955 
      raise result.ex
483 rajveer 1956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1957 
 
483 rajveer 1958 
  def getLineItemsForOrder(self, orderId):
94 ashish 1959 
    """
1960 
    Parameters:
483 rajveer 1961 
     - orderId
94 ashish 1962 
    """
483 rajveer 1963 
    self.send_getLineItemsForOrder(orderId)
1964 
    return self.recv_getLineItemsForOrder()
94 ashish 1965 
 
483 rajveer 1966 
  def send_getLineItemsForOrder(self, orderId):
1967 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1968 
    args = getLineItemsForOrder_args()
1969 
    args.orderId = orderId
94 ashish 1970 
    args.write(self._oprot)
1971 
    self._oprot.writeMessageEnd()
1972 
    self._oprot.trans.flush()
1973 
 
483 rajveer 1974 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1976 
    if mtype == TMessageType.EXCEPTION:
1977 
      x = TApplicationException()
1978 
      x.read(self._iprot)
1979 
      self._iprot.readMessageEnd()
1980 
      raise x
483 rajveer 1981 
    result = getLineItemsForOrder_result()
94 ashish 1982 
    result.read(self._iprot)
1983 
    self._iprot.readMessageEnd()
3431 rajveer 1984 
    if result.success is not None:
94 ashish 1985 
      return result.success
3431 rajveer 1986 
    if result.ex is not None:
94 ashish 1987 
      raise result.ex
483 rajveer 1988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1989 
 
4999 phani.kuma 1990 
  def getOrderList(self, order_ids):
1991 
    """
1992 
    Parameters:
1993 
     - order_ids
1994 
    """
1995 
    self.send_getOrderList(order_ids)
1996 
    return self.recv_getOrderList()
1997 
 
1998 
  def send_getOrderList(self, order_ids):
1999 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2000 
    args = getOrderList_args()
2001 
    args.order_ids = order_ids
2002 
    args.write(self._oprot)
2003 
    self._oprot.writeMessageEnd()
2004 
    self._oprot.trans.flush()
2005 
 
2006 
  def recv_getOrderList(self, ):
2007 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2008 
    if mtype == TMessageType.EXCEPTION:
2009 
      x = TApplicationException()
2010 
      x.read(self._iprot)
2011 
      self._iprot.readMessageEnd()
2012 
      raise x
2013 
    result = getOrderList_result()
2014 
    result.read(self._iprot)
2015 
    self._iprot.readMessageEnd()
2016 
    if result.success is not None:
2017 
      return result.success
2018 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2019 
 
5386 phani.kuma 2020 
  def getOrderListForVendor(self, order_ids, vendorId):
2021 
    """
2022 
    Parameters:
2023 
     - order_ids
2024 
     - vendorId
2025 
    """
2026 
    self.send_getOrderListForVendor(order_ids, vendorId)
2027 
    return self.recv_getOrderListForVendor()
2028 
 
2029 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2030 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2031 
    args = getOrderListForVendor_args()
2032 
    args.order_ids = order_ids
2033 
    args.vendorId = vendorId
2034 
    args.write(self._oprot)
2035 
    self._oprot.writeMessageEnd()
2036 
    self._oprot.trans.flush()
2037 
 
2038 
  def recv_getOrderListForVendor(self, ):
2039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2040 
    if mtype == TMessageType.EXCEPTION:
2041 
      x = TApplicationException()
2042 
      x.read(self._iprot)
2043 
      self._iprot.readMessageEnd()
2044 
      raise x
2045 
    result = getOrderListForVendor_result()
2046 
    result.read(self._iprot)
2047 
    self._iprot.readMessageEnd()
2048 
    if result.success is not None:
2049 
      return result.success
2050 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2051 
 
1528 ankur.sing 2052 
  def getOrderForCustomer(self, orderId, customerId):
2053 
    """
2054 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2055 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2056 
 
1528 ankur.sing 2057 
    Parameters:
2058 
     - orderId
2059 
     - customerId
2060 
    """
2061 
    self.send_getOrderForCustomer(orderId, customerId)
2062 
    return self.recv_getOrderForCustomer()
2063 
 
2064 
  def send_getOrderForCustomer(self, orderId, customerId):
2065 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2066 
    args = getOrderForCustomer_args()
2067 
    args.orderId = orderId
2068 
    args.customerId = customerId
2069 
    args.write(self._oprot)
2070 
    self._oprot.writeMessageEnd()
2071 
    self._oprot.trans.flush()
2072 
 
2073 
  def recv_getOrderForCustomer(self, ):
2074 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2075 
    if mtype == TMessageType.EXCEPTION:
2076 
      x = TApplicationException()
2077 
      x.read(self._iprot)
2078 
      self._iprot.readMessageEnd()
2079 
      raise x
2080 
    result = getOrderForCustomer_result()
2081 
    result.read(self._iprot)
2082 
    self._iprot.readMessageEnd()
3431 rajveer 2083 
    if result.success is not None:
1528 ankur.sing 2084 
      return result.success
3431 rajveer 2085 
    if result.ex is not None:
1528 ankur.sing 2086 
      raise result.ex
2087 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2088 
 
4444 rajveer 2089 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2090 
    """
2091 
    Parameters:
4394 rajveer 2092 
     - type
4444 rajveer 2093 
     - warehouseId
4394 rajveer 2094 
     - status
2095 
     - timestamp
3064 chandransh 2096 
    """
4444 rajveer 2097 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2098 
    return self.recv_getAlerts()
2099 
 
4444 rajveer 2100 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2101 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2102 
    args = getAlerts_args()
4394 rajveer 2103 
    args.type = type
4444 rajveer 2104 
    args.warehouseId = warehouseId
4394 rajveer 2105 
    args.status = status
2106 
    args.timestamp = timestamp
3064 chandransh 2107 
    args.write(self._oprot)
2108 
    self._oprot.writeMessageEnd()
2109 
    self._oprot.trans.flush()
2110 
 
2111 
  def recv_getAlerts(self, ):
2112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2113 
    if mtype == TMessageType.EXCEPTION:
2114 
      x = TApplicationException()
2115 
      x.read(self._iprot)
2116 
      self._iprot.readMessageEnd()
2117 
      raise x
2118 
    result = getAlerts_result()
2119 
    result.read(self._iprot)
2120 
    self._iprot.readMessageEnd()
3431 rajveer 2121 
    if result.success is not None:
3064 chandransh 2122 
      return result.success
2123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2124 
 
4444 rajveer 2125 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2126 
    """
2127 
    Parameters:
2128 
     - type
4444 rajveer 2129 
     - warehouseId
4394 rajveer 2130 
     - description
3064 chandransh 2131 
    """
4444 rajveer 2132 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2133 
    self.recv_addAlert()
3064 chandransh 2134 
 
4444 rajveer 2135 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2136 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2137 
    args = addAlert_args()
3064 chandransh 2138 
    args.type = type
4444 rajveer 2139 
    args.warehouseId = warehouseId
4394 rajveer 2140 
    args.description = description
3064 chandransh 2141 
    args.write(self._oprot)
2142 
    self._oprot.writeMessageEnd()
2143 
    self._oprot.trans.flush()
2144 
 
4394 rajveer 2145 
  def recv_addAlert(self, ):
3064 chandransh 2146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2147 
    if mtype == TMessageType.EXCEPTION:
2148 
      x = TApplicationException()
2149 
      x.read(self._iprot)
2150 
      self._iprot.readMessageEnd()
2151 
      raise x
4394 rajveer 2152 
    result = addAlert_result()
3064 chandransh 2153 
    result.read(self._iprot)
2154 
    self._iprot.readMessageEnd()
2155 
    return
2156 
 
4444 rajveer 2157 
  def markAlertsAsSeen(self, warehouseId):
2158 
    """
2159 
    Parameters:
2160 
     - warehouseId
2161 
    """
2162 
    self.send_markAlertsAsSeen(warehouseId)
2163 
    self.recv_markAlertsAsSeen()
2164 
 
2165 
  def send_markAlertsAsSeen(self, warehouseId):
2166 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2167 
    args = markAlertsAsSeen_args()
2168 
    args.warehouseId = warehouseId
2169 
    args.write(self._oprot)
2170 
    self._oprot.writeMessageEnd()
2171 
    self._oprot.trans.flush()
2172 
 
2173 
  def recv_markAlertsAsSeen(self, ):
2174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2175 
    if mtype == TMessageType.EXCEPTION:
2176 
      x = TApplicationException()
2177 
      x.read(self._iprot)
2178 
      self._iprot.readMessageEnd()
2179 
      raise x
2180 
    result = markAlertsAsSeen_result()
2181 
    result.read(self._iprot)
2182 
    self._iprot.readMessageEnd()
2183 
    return
2184 
 
3064 chandransh 2185 
  def getValidOrderCount(self, ):
2186 
    """
2187 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2188 
    """
2189 
    self.send_getValidOrderCount()
2190 
    return self.recv_getValidOrderCount()
2191 
 
2192 
  def send_getValidOrderCount(self, ):
2193 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2194 
    args = getValidOrderCount_args()
2195 
    args.write(self._oprot)
2196 
    self._oprot.writeMessageEnd()
2197 
    self._oprot.trans.flush()
2198 
 
2199 
  def recv_getValidOrderCount(self, ):
2200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2201 
    if mtype == TMessageType.EXCEPTION:
2202 
      x = TApplicationException()
2203 
      x.read(self._iprot)
2204 
      self._iprot.readMessageEnd()
2205 
      raise x
2206 
    result = getValidOrderCount_result()
2207 
    result.read(self._iprot)
2208 
    self._iprot.readMessageEnd()
3431 rajveer 2209 
    if result.success is not None:
3064 chandransh 2210 
      return result.success
2211 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2212 
 
2213 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2214 
    """
2215 
    Returns the number of distinct customers who have done successful transactions
2216 
    """
2217 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2218 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2219 
 
2220 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2221 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2222 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2223 
    args.write(self._oprot)
2224 
    self._oprot.writeMessageEnd()
2225 
    self._oprot.trans.flush()
2226 
 
2227 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2229 
    if mtype == TMessageType.EXCEPTION:
2230 
      x = TApplicationException()
2231 
      x.read(self._iprot)
2232 
      self._iprot.readMessageEnd()
2233 
      raise x
2234 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2235 
    result.read(self._iprot)
2236 
    self._iprot.readMessageEnd()
3431 rajveer 2237 
    if result.success is not None:
3064 chandransh 2238 
      return result.success
2239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2240 
 
2241 
  def getValidOrdersAmountRange(self, ):
2242 
    """
2243 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2244 
    List contains two values, first minimum amount and second maximum amount.
2245 
    """
2246 
    self.send_getValidOrdersAmountRange()
2247 
    return self.recv_getValidOrdersAmountRange()
2248 
 
2249 
  def send_getValidOrdersAmountRange(self, ):
2250 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2251 
    args = getValidOrdersAmountRange_args()
2252 
    args.write(self._oprot)
2253 
    self._oprot.writeMessageEnd()
2254 
    self._oprot.trans.flush()
2255 
 
2256 
  def recv_getValidOrdersAmountRange(self, ):
2257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2258 
    if mtype == TMessageType.EXCEPTION:
2259 
      x = TApplicationException()
2260 
      x.read(self._iprot)
2261 
      self._iprot.readMessageEnd()
2262 
      raise x
2263 
    result = getValidOrdersAmountRange_result()
2264 
    result.read(self._iprot)
2265 
    self._iprot.readMessageEnd()
3431 rajveer 2266 
    if result.success is not None:
3064 chandransh 2267 
      return result.success
2268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2269 
 
2270 
  def getValidOrders(self, limit):
2271 
    """
2272 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2273 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2274 
 
3064 chandransh 2275 
    Parameters:
2276 
     - limit
2277 
    """
2278 
    self.send_getValidOrders(limit)
2279 
    return self.recv_getValidOrders()
2280 
 
2281 
  def send_getValidOrders(self, limit):
2282 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2283 
    args = getValidOrders_args()
2284 
    args.limit = limit
2285 
    args.write(self._oprot)
2286 
    self._oprot.writeMessageEnd()
2287 
    self._oprot.trans.flush()
2288 
 
2289 
  def recv_getValidOrders(self, ):
2290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2291 
    if mtype == TMessageType.EXCEPTION:
2292 
      x = TApplicationException()
2293 
      x.read(self._iprot)
2294 
      self._iprot.readMessageEnd()
2295 
      raise x
2296 
    result = getValidOrders_result()
2297 
    result.read(self._iprot)
2298 
    self._iprot.readMessageEnd()
3431 rajveer 2299 
    if result.success is not None:
3064 chandransh 2300 
      return result.success
2301 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2302 
 
1220 chandransh 2303 
  def batchOrders(self, warehouseId):
2304 
    """
2305 
    Create a batch of all the pending orders for the given warehouse.
2306 
    The returned list is orderd by created_timestamp.
2307 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2308 
 
1220 chandransh 2309 
    Parameters:
2310 
     - warehouseId
2311 
    """
2312 
    self.send_batchOrders(warehouseId)
2313 
    return self.recv_batchOrders()
2314 
 
2315 
  def send_batchOrders(self, warehouseId):
2316 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2317 
    args = batchOrders_args()
2318 
    args.warehouseId = warehouseId
2319 
    args.write(self._oprot)
2320 
    self._oprot.writeMessageEnd()
2321 
    self._oprot.trans.flush()
2322 
 
2323 
  def recv_batchOrders(self, ):
2324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2325 
    if mtype == TMessageType.EXCEPTION:
2326 
      x = TApplicationException()
2327 
      x.read(self._iprot)
2328 
      self._iprot.readMessageEnd()
2329 
      raise x
2330 
    result = batchOrders_result()
2331 
    result.read(self._iprot)
2332 
    self._iprot.readMessageEnd()
3431 rajveer 2333 
    if result.success is not None:
1220 chandransh 2334 
      return result.success
3431 rajveer 2335 
    if result.ex is not None:
1220 chandransh 2336 
      raise result.ex
2337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2338 
 
1208 chandransh 2339 
  def markOrderAsOutOfStock(self, orderId):
2340 
    """
2341 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2342 
 
1208 chandransh 2343 
    Parameters:
2344 
     - orderId
2345 
    """
2346 
    self.send_markOrderAsOutOfStock(orderId)
2347 
    return self.recv_markOrderAsOutOfStock()
2348 
 
2349 
  def send_markOrderAsOutOfStock(self, orderId):
2350 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2351 
    args = markOrderAsOutOfStock_args()
2352 
    args.orderId = orderId
2353 
    args.write(self._oprot)
2354 
    self._oprot.writeMessageEnd()
2355 
    self._oprot.trans.flush()
2356 
 
2357 
  def recv_markOrderAsOutOfStock(self, ):
2358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2359 
    if mtype == TMessageType.EXCEPTION:
2360 
      x = TApplicationException()
2361 
      x.read(self._iprot)
2362 
      self._iprot.readMessageEnd()
2363 
      raise x
2364 
    result = markOrderAsOutOfStock_result()
2365 
    result.read(self._iprot)
2366 
    self._iprot.readMessageEnd()
3431 rajveer 2367 
    if result.success is not None:
1208 chandransh 2368 
      return result.success
3431 rajveer 2369 
    if result.ex is not None:
1208 chandransh 2370 
      raise result.ex
2371 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2372 
 
3064 chandransh 2373 
  def verifyOrder(self, orderId):
759 chandransh 2374 
    """
3064 chandransh 2375 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2376 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2377 
    used for all other orders as well.
2378 
    Throws an exception if no such order exists.
3431 rajveer 2379 
 
759 chandransh 2380 
    Parameters:
3064 chandransh 2381 
     - orderId
759 chandransh 2382 
    """
3064 chandransh 2383 
    self.send_verifyOrder(orderId)
2384 
    return self.recv_verifyOrder()
759 chandransh 2385 
 
3064 chandransh 2386 
  def send_verifyOrder(self, orderId):
2387 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2388 
    args = verifyOrder_args()
2389 
    args.orderId = orderId
759 chandransh 2390 
    args.write(self._oprot)
2391 
    self._oprot.writeMessageEnd()
2392 
    self._oprot.trans.flush()
2393 
 
3064 chandransh 2394 
  def recv_verifyOrder(self, ):
759 chandransh 2395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2396 
    if mtype == TMessageType.EXCEPTION:
2397 
      x = TApplicationException()
2398 
      x.read(self._iprot)
2399 
      self._iprot.readMessageEnd()
2400 
      raise x
3064 chandransh 2401 
    result = verifyOrder_result()
759 chandransh 2402 
    result.read(self._iprot)
2403 
    self._iprot.readMessageEnd()
3431 rajveer 2404 
    if result.success is not None:
759 chandransh 2405 
      return result.success
3431 rajveer 2406 
    if result.ex is not None:
759 chandransh 2407 
      raise result.ex
3064 chandransh 2408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2409 
 
3064 chandransh 2410 
  def acceptOrder(self, orderId):
1113 chandransh 2411 
    """
3064 chandransh 2412 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2413 
    given order is not a COD order, it also captures the payment if the same has
2414 
    not been captured.
2415 
    Throws an exception if no such order exists.
3431 rajveer 2416 
 
1113 chandransh 2417 
    Parameters:
3064 chandransh 2418 
     - orderId
1113 chandransh 2419 
    """
3064 chandransh 2420 
    self.send_acceptOrder(orderId)
2421 
    return self.recv_acceptOrder()
1113 chandransh 2422 
 
3064 chandransh 2423 
  def send_acceptOrder(self, orderId):
2424 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2425 
    args = acceptOrder_args()
2426 
    args.orderId = orderId
1113 chandransh 2427 
    args.write(self._oprot)
2428 
    self._oprot.writeMessageEnd()
2429 
    self._oprot.trans.flush()
2430 
 
3064 chandransh 2431 
  def recv_acceptOrder(self, ):
1113 chandransh 2432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2433 
    if mtype == TMessageType.EXCEPTION:
2434 
      x = TApplicationException()
2435 
      x.read(self._iprot)
2436 
      self._iprot.readMessageEnd()
2437 
      raise x
3064 chandransh 2438 
    result = acceptOrder_result()
1113 chandransh 2439 
    result.read(self._iprot)
2440 
    self._iprot.readMessageEnd()
3431 rajveer 2441 
    if result.success is not None:
1113 chandransh 2442 
      return result.success
3431 rajveer 2443 
    if result.ex is not None:
1113 chandransh 2444 
      raise result.ex
3064 chandransh 2445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2446 
 
5110 mandeep.dh 2447 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2448 
    """
3064 chandransh 2449 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2450 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2451 
    the IMEI no. if a -1 is supplied.
2452 
    Also, it generates an invoice number for the order, marks the order as
2453 
    BILLED and sets the billing timestamp.
2454 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2455 
 
1135 chandransh 2456 
    Parameters:
3064 chandransh 2457 
     - orderId
2458 
     - invoice_number
4658 mandeep.dh 2459 
     - serialNumber
4283 anupam.sin 2460 
     - itemNumber
3064 chandransh 2461 
     - billed_by
4264 rajveer 2462 
     - jacketNumber
4283 anupam.sin 2463 
     - billingType
5110 mandeep.dh 2464 
     - fulfilmentWarehouseId
4763 rajveer 2465 
     - authorize
1135 chandransh 2466 
    """
5110 mandeep.dh 2467 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2468 
    return self.recv_addBillingDetails()
1135 chandransh 2469 
 
5110 mandeep.dh 2470 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2471 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2472 
    args = addBillingDetails_args()
2473 
    args.orderId = orderId
2474 
    args.invoice_number = invoice_number
4658 mandeep.dh 2475 
    args.serialNumber = serialNumber
4283 anupam.sin 2476 
    args.itemNumber = itemNumber
3064 chandransh 2477 
    args.billed_by = billed_by
4264 rajveer 2478 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2479 
    args.billingType = billingType
5110 mandeep.dh 2480 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2481 
    args.authorize = authorize
1135 chandransh 2482 
    args.write(self._oprot)
2483 
    self._oprot.writeMessageEnd()
2484 
    self._oprot.trans.flush()
2485 
 
3064 chandransh 2486 
  def recv_addBillingDetails(self, ):
1135 chandransh 2487 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2488 
    if mtype == TMessageType.EXCEPTION:
2489 
      x = TApplicationException()
2490 
      x.read(self._iprot)
2491 
      self._iprot.readMessageEnd()
2492 
      raise x
3064 chandransh 2493 
    result = addBillingDetails_result()
1135 chandransh 2494 
    result.read(self._iprot)
2495 
    self._iprot.readMessageEnd()
3431 rajveer 2496 
    if result.success is not None:
3064 chandransh 2497 
      return result.success
3431 rajveer 2498 
    if result.ex is not None:
1135 chandransh 2499 
      raise result.ex
3064 chandransh 2500 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2501 
 
4763 rajveer 2502 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2503 
    """
2504 
    Add the invoice number to the order.
2505 
 
2506 
    Parameters:
2507 
     - orderId
2508 
     - invoiceNumber
4763 rajveer 2509 
     - color
4579 rajveer 2510 
    """
4763 rajveer 2511 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2512 
    self.recv_addInvoiceNumber()
2513 
 
4763 rajveer 2514 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2515 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2516 
    args = addInvoiceNumber_args()
2517 
    args.orderId = orderId
2518 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2519 
    args.color = color
4579 rajveer 2520 
    args.write(self._oprot)
2521 
    self._oprot.writeMessageEnd()
2522 
    self._oprot.trans.flush()
2523 
 
2524 
  def recv_addInvoiceNumber(self, ):
2525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2526 
    if mtype == TMessageType.EXCEPTION:
2527 
      x = TApplicationException()
2528 
      x.read(self._iprot)
2529 
      self._iprot.readMessageEnd()
2530 
      raise x
2531 
    result = addInvoiceNumber_result()
2532 
    result.read(self._iprot)
2533 
    self._iprot.readMessageEnd()
2534 
    if result.ex is not None:
2535 
      raise result.ex
2536 
    return
2537 
 
4910 phani.kuma 2538 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2539 
    """
3064 chandransh 2540 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2541 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2542 
 
1408 ankur.sing 2543 
    Parameters:
3064 chandransh 2544 
     - warehouseId
1408 ankur.sing 2545 
     - providerId
3064 chandransh 2546 
     - cod
4910 phani.kuma 2547 
     - orderIds
1408 ankur.sing 2548 
    """
4910 phani.kuma 2549 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2550 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2551 
 
4910 phani.kuma 2552 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2553 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2554 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2555 
    args.warehouseId = warehouseId
1408 ankur.sing 2556 
    args.providerId = providerId
3064 chandransh 2557 
    args.cod = cod
4910 phani.kuma 2558 
    args.orderIds = orderIds
1408 ankur.sing 2559 
    args.write(self._oprot)
2560 
    self._oprot.writeMessageEnd()
2561 
    self._oprot.trans.flush()
2562 
 
4910 phani.kuma 2563 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2564 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2565 
    if mtype == TMessageType.EXCEPTION:
2566 
      x = TApplicationException()
2567 
      x.read(self._iprot)
2568 
      self._iprot.readMessageEnd()
2569 
      raise x
4910 phani.kuma 2570 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2571 
    result.read(self._iprot)
2572 
    self._iprot.readMessageEnd()
3431 rajveer 2573 
    if result.success is not None:
1408 ankur.sing 2574 
      return result.success
3431 rajveer 2575 
    if result.ex is not None:
3064 chandransh 2576 
      raise result.ex
4910 phani.kuma 2577 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2578 
 
5713 rajveer 2579 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2580 
    """
2581 
    Parameters:
2582 
     - providerId
2583 
     - orderIds
5713 rajveer 2584 
     - awbs
5676 rajveer 2585 
    """
5713 rajveer 2586 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2587 
    return self.recv_markOrdersAsReturnedFromStore()
2588 
 
5713 rajveer 2589 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2590 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2591 
    args = markOrdersAsReturnedFromStore_args()
2592 
    args.providerId = providerId
2593 
    args.orderIds = orderIds
5713 rajveer 2594 
    args.awbs = awbs
5676 rajveer 2595 
    args.write(self._oprot)
2596 
    self._oprot.writeMessageEnd()
2597 
    self._oprot.trans.flush()
2598 
 
2599 
  def recv_markOrdersAsReturnedFromStore(self, ):
2600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2601 
    if mtype == TMessageType.EXCEPTION:
2602 
      x = TApplicationException()
2603 
      x.read(self._iprot)
2604 
      self._iprot.readMessageEnd()
2605 
      raise x
2606 
    result = markOrdersAsReturnedFromStore_result()
2607 
    result.read(self._iprot)
2608 
    self._iprot.readMessageEnd()
2609 
    if result.success is not None:
2610 
      return result.success
2611 
    if result.ex is not None:
2612 
      raise result.ex
2613 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2614 
 
4910 phani.kuma 2615 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2616 
    """
4910 phani.kuma 2617 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2618 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2619 
 
2620 
    Parameters:
2621 
     - providerId
4910 phani.kuma 2622 
     - pickupDetails
4410 rajveer 2623 
    """
4910 phani.kuma 2624 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2625 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2626 
 
4910 phani.kuma 2627 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2628 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2629 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2630 
    args.providerId = providerId
4910 phani.kuma 2631 
    args.pickupDetails = pickupDetails
4410 rajveer 2632 
    args.write(self._oprot)
2633 
    self._oprot.writeMessageEnd()
2634 
    self._oprot.trans.flush()
2635 
 
4910 phani.kuma 2636 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2638 
    if mtype == TMessageType.EXCEPTION:
2639 
      x = TApplicationException()
2640 
      x.read(self._iprot)
2641 
      self._iprot.readMessageEnd()
2642 
      raise x
4910 phani.kuma 2643 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2644 
    result.read(self._iprot)
2645 
    self._iprot.readMessageEnd()
2646 
    if result.ex is not None:
2647 
      raise result.ex
4910 phani.kuma 2648 
    return
4410 rajveer 2649 
 
4910 phani.kuma 2650 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2651 
    """
3064 chandransh 2652 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2653 
 
94 ashish 2654 
    Parameters:
3064 chandransh 2655 
     - providerId
304 ashish 2656 
    """
4910 phani.kuma 2657 
    self.send_getOrdersNotPickedUp(providerId)
2658 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2659 
 
4910 phani.kuma 2660 
  def send_getOrdersNotPickedUp(self, providerId):
2661 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2662 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2663 
    args.providerId = providerId
304 ashish 2664 
    args.write(self._oprot)
2665 
    self._oprot.writeMessageEnd()
2666 
    self._oprot.trans.flush()
2667 
 
4910 phani.kuma 2668 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2669 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2670 
    if mtype == TMessageType.EXCEPTION:
2671 
      x = TApplicationException()
2672 
      x.read(self._iprot)
2673 
      self._iprot.readMessageEnd()
2674 
      raise x
4910 phani.kuma 2675 
    result = getOrdersNotPickedUp_result()
304 ashish 2676 
    result.read(self._iprot)
2677 
    self._iprot.readMessageEnd()
3431 rajveer 2678 
    if result.success is not None:
304 ashish 2679 
      return result.success
4910 phani.kuma 2680 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2681 
 
3064 chandransh 2682 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2683 
    """
3064 chandransh 2684 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2685 
    the name of the receiver.
2686 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2687 
 
304 ashish 2688 
    Parameters:
3064 chandransh 2689 
     - providerId
2690 
     - deliveredOrders
304 ashish 2691 
    """
3064 chandransh 2692 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2693 
    self.recv_markOrdersAsDelivered()
304 ashish 2694 
 
3064 chandransh 2695 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2696 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2697 
    args = markOrdersAsDelivered_args()
2698 
    args.providerId = providerId
2699 
    args.deliveredOrders = deliveredOrders
304 ashish 2700 
    args.write(self._oprot)
2701 
    self._oprot.writeMessageEnd()
2702 
    self._oprot.trans.flush()
2703 
 
3064 chandransh 2704 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2706 
    if mtype == TMessageType.EXCEPTION:
2707 
      x = TApplicationException()
2708 
      x.read(self._iprot)
2709 
      self._iprot.readMessageEnd()
2710 
      raise x
3064 chandransh 2711 
    result = markOrdersAsDelivered_result()
304 ashish 2712 
    result.read(self._iprot)
2713 
    self._iprot.readMessageEnd()
3431 rajveer 2714 
    if result.ex is not None:
3064 chandransh 2715 
      raise result.ex
304 ashish 2716 
    return
2717 
 
4910 phani.kuma 2718 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2719 
    """
4910 phani.kuma 2720 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2721 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2722 
 
3064 chandransh 2723 
    Parameters:
2724 
     - providerId
2725 
     - returnedOrders
1596 ankur.sing 2726 
    """
4910 phani.kuma 2727 
    self.send_markAsRTOrders(providerId, returnedOrders)
2728 
    self.recv_markAsRTOrders()
304 ashish 2729 
 
4910 phani.kuma 2730 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2731 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2732 
    args = markAsRTOrders_args()
3064 chandransh 2733 
    args.providerId = providerId
2734 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2735 
    args.write(self._oprot)
2736 
    self._oprot.writeMessageEnd()
2737 
    self._oprot.trans.flush()
2738 
 
4910 phani.kuma 2739 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2741 
    if mtype == TMessageType.EXCEPTION:
2742 
      x = TApplicationException()
2743 
      x.read(self._iprot)
2744 
      self._iprot.readMessageEnd()
2745 
      raise x
4910 phani.kuma 2746 
    result = markAsRTOrders_result()
1596 ankur.sing 2747 
    result.read(self._iprot)
2748 
    self._iprot.readMessageEnd()
3431 rajveer 2749 
    if result.ex is not None:
3064 chandransh 2750 
      raise result.ex
2751 
    return
1596 ankur.sing 2752 
 
4910 phani.kuma 2753 
  def getRTOrders(self, providerId):
2754 
    """
2755 
    Returns a list of orders that were returned by courier.
2756 
 
2757 
    Parameters:
2758 
     - providerId
2759 
    """
2760 
    self.send_getRTOrders(providerId)
2761 
    return self.recv_getRTOrders()
2762 
 
2763 
  def send_getRTOrders(self, providerId):
2764 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2765 
    args = getRTOrders_args()
2766 
    args.providerId = providerId
2767 
    args.write(self._oprot)
2768 
    self._oprot.writeMessageEnd()
2769 
    self._oprot.trans.flush()
2770 
 
2771 
  def recv_getRTOrders(self, ):
2772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2773 
    if mtype == TMessageType.EXCEPTION:
2774 
      x = TApplicationException()
2775 
      x.read(self._iprot)
2776 
      self._iprot.readMessageEnd()
2777 
      raise x
2778 
    result = getRTOrders_result()
2779 
    result.read(self._iprot)
2780 
    self._iprot.readMessageEnd()
2781 
    if result.success is not None:
2782 
      return result.success
2783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2784 
 
3064 chandransh 2785 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2786 
    """
3064 chandransh 2787 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2788 
 
3064 chandransh 2789 
    Parameters:
2790 
     - providerId
2791 
     - undeliveredOrders
1627 ankur.sing 2792 
    """
3064 chandransh 2793 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2794 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2795 
 
3064 chandransh 2796 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2797 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2798 
    args = updateNonDeliveryReason_args()
2799 
    args.providerId = providerId
2800 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2801 
    args.write(self._oprot)
2802 
    self._oprot.writeMessageEnd()
2803 
    self._oprot.trans.flush()
2804 
 
3064 chandransh 2805 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2806 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2807 
    if mtype == TMessageType.EXCEPTION:
2808 
      x = TApplicationException()
2809 
      x.read(self._iprot)
2810 
      self._iprot.readMessageEnd()
2811 
      raise x
3064 chandransh 2812 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2813 
    result.read(self._iprot)
2814 
    self._iprot.readMessageEnd()
4910 phani.kuma 2815 
    if result.ex is not None:
2816 
      raise result.ex
2817 
    return
2818 
 
2819 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2820 
    """
2821 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2822 
 
2823 
    Parameters:
2824 
     - providerId
2825 
    """
2826 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2827 
    return self.recv_getNonDeliveredOrdersbyCourier()
2828 
 
2829 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2830 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2831 
    args = getNonDeliveredOrdersbyCourier_args()
2832 
    args.providerId = providerId
2833 
    args.write(self._oprot)
2834 
    self._oprot.writeMessageEnd()
2835 
    self._oprot.trans.flush()
2836 
 
2837 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2839 
    if mtype == TMessageType.EXCEPTION:
2840 
      x = TApplicationException()
2841 
      x.read(self._iprot)
2842 
      self._iprot.readMessageEnd()
2843 
      raise x
2844 
    result = getNonDeliveredOrdersbyCourier_result()
2845 
    result.read(self._iprot)
2846 
    self._iprot.readMessageEnd()
4581 phani.kuma 2847 
    if result.success is not None:
2848 
      return result.success
4910 phani.kuma 2849 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2850 
 
2851 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2852 
    """
2853 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2854 
 
2855 
    Parameters:
2856 
     - providerId
2857 
     - local_connected_orders
2858 
    """
2859 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2860 
    self.recv_markOrdersAsLocalConnected()
2861 
 
2862 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2863 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2864 
    args = markOrdersAsLocalConnected_args()
2865 
    args.providerId = providerId
2866 
    args.local_connected_orders = local_connected_orders
2867 
    args.write(self._oprot)
2868 
    self._oprot.writeMessageEnd()
2869 
    self._oprot.trans.flush()
2870 
 
2871 
  def recv_markOrdersAsLocalConnected(self, ):
2872 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2873 
    if mtype == TMessageType.EXCEPTION:
2874 
      x = TApplicationException()
2875 
      x.read(self._iprot)
2876 
      self._iprot.readMessageEnd()
2877 
      raise x
2878 
    result = markOrdersAsLocalConnected_result()
2879 
    result.read(self._iprot)
2880 
    self._iprot.readMessageEnd()
3431 rajveer 2881 
    if result.ex is not None:
3064 chandransh 2882 
      raise result.ex
4910 phani.kuma 2883 
    return
1627 ankur.sing 2884 
 
4910 phani.kuma 2885 
  def getOrdersNotLocalConnected(self, providerId):
2886 
    """
2887 
    Returns a list of orders that were picked up or shipped but pending local connection.
2888 
 
2889 
    Parameters:
2890 
     - providerId
2891 
    """
2892 
    self.send_getOrdersNotLocalConnected(providerId)
2893 
    return self.recv_getOrdersNotLocalConnected()
2894 
 
2895 
  def send_getOrdersNotLocalConnected(self, providerId):
2896 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
2897 
    args = getOrdersNotLocalConnected_args()
2898 
    args.providerId = providerId
2899 
    args.write(self._oprot)
2900 
    self._oprot.writeMessageEnd()
2901 
    self._oprot.trans.flush()
2902 
 
2903 
  def recv_getOrdersNotLocalConnected(self, ):
2904 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2905 
    if mtype == TMessageType.EXCEPTION:
2906 
      x = TApplicationException()
2907 
      x.read(self._iprot)
2908 
      self._iprot.readMessageEnd()
2909 
      raise x
2910 
    result = getOrdersNotLocalConnected_result()
2911 
    result.read(self._iprot)
2912 
    self._iprot.readMessageEnd()
2913 
    if result.success is not None:
2914 
      return result.success
2915 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
2916 
 
2917 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2918 
    """
2919 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
2920 
 
2921 
    Parameters:
2922 
     - providerId
2923 
     - destination_city_reached_orders
2924 
    """
2925 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
2926 
    self.recv_markOrdersAsDestinationCityReached()
2927 
 
2928 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
2929 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
2930 
    args = markOrdersAsDestinationCityReached_args()
2931 
    args.providerId = providerId
2932 
    args.destination_city_reached_orders = destination_city_reached_orders
2933 
    args.write(self._oprot)
2934 
    self._oprot.writeMessageEnd()
2935 
    self._oprot.trans.flush()
2936 
 
2937 
  def recv_markOrdersAsDestinationCityReached(self, ):
2938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2939 
    if mtype == TMessageType.EXCEPTION:
2940 
      x = TApplicationException()
2941 
      x.read(self._iprot)
2942 
      self._iprot.readMessageEnd()
2943 
      raise x
2944 
    result = markOrdersAsDestinationCityReached_result()
2945 
    result.read(self._iprot)
2946 
    self._iprot.readMessageEnd()
2947 
    if result.ex is not None:
2948 
      raise result.ex
2949 
    return
2950 
 
2951 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2952 
    """
2953 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
2954 
 
2955 
    Parameters:
2956 
     - providerId
2957 
     - first_atdl_orders
2958 
    """
2959 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
2960 
    self.recv_markOrdersAsFirstDeliveryAttempted()
2961 
 
2962 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
2963 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
2964 
    args = markOrdersAsFirstDeliveryAttempted_args()
2965 
    args.providerId = providerId
2966 
    args.first_atdl_orders = first_atdl_orders
2967 
    args.write(self._oprot)
2968 
    self._oprot.writeMessageEnd()
2969 
    self._oprot.trans.flush()
2970 
 
2971 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
2972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2973 
    if mtype == TMessageType.EXCEPTION:
2974 
      x = TApplicationException()
2975 
      x.read(self._iprot)
2976 
      self._iprot.readMessageEnd()
2977 
      raise x
2978 
    result = markOrdersAsFirstDeliveryAttempted_result()
2979 
    result.read(self._iprot)
2980 
    self._iprot.readMessageEnd()
2981 
    if result.ex is not None:
2982 
      raise result.ex
2983 
    return
2984 
 
3064 chandransh 2985 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 2986 
    """
3064 chandransh 2987 
    Returns the list of orders whose delivery time has passed but have not been
2988 
    delivered yet for the given provider and warehouse. To get a complete list of
2989 
    undelivered orders, pass them as -1.
2990 
    Returns an empty list if no such orders exist.
3431 rajveer 2991 
 
1886 ankur.sing 2992 
    Parameters:
3064 chandransh 2993 
     - providerId
2994 
     - warehouseId
1886 ankur.sing 2995 
    """
3064 chandransh 2996 
    self.send_getUndeliveredOrders(providerId, warehouseId)
2997 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 2998 
 
3064 chandransh 2999 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3000 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3001 
    args = getUndeliveredOrders_args()
3002 
    args.providerId = providerId
3003 
    args.warehouseId = warehouseId
1886 ankur.sing 3004 
    args.write(self._oprot)
3005 
    self._oprot.writeMessageEnd()
3006 
    self._oprot.trans.flush()
3007 
 
3064 chandransh 3008 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3009 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3010 
    if mtype == TMessageType.EXCEPTION:
3011 
      x = TApplicationException()
3012 
      x.read(self._iprot)
3013 
      self._iprot.readMessageEnd()
3014 
      raise x
3064 chandransh 3015 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3016 
    result.read(self._iprot)
3017 
    self._iprot.readMessageEnd()
3431 rajveer 3018 
    if result.success is not None:
1886 ankur.sing 3019 
      return result.success
3064 chandransh 3020 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3021 
 
4783 phani.kuma 3022 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3023 
    """
3024 
    Returns the list of orders whose expected delivery date has passed but have not been
3025 
    delivered yet.
3026 
    Returns an empty list if no such orders exist.
3027 
    """
3028 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3029 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3030 
 
3031 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3032 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3033 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3034 
    args.write(self._oprot)
3035 
    self._oprot.writeMessageEnd()
3036 
    self._oprot.trans.flush()
3037 
 
3038 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3040 
    if mtype == TMessageType.EXCEPTION:
3041 
      x = TApplicationException()
3042 
      x.read(self._iprot)
3043 
      self._iprot.readMessageEnd()
3044 
      raise x
3045 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3046 
    result.read(self._iprot)
3047 
    self._iprot.readMessageEnd()
3048 
    if result.success is not None:
3049 
      return result.success
3050 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3051 
 
2536 chandransh 3052 
  def toggleDOAFlag(self, orderId):
3053 
    """
3054 
    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.
3055 
    Returns the final flag status.
3056 
    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 3057 
 
2536 chandransh 3058 
    Parameters:
3059 
     - orderId
3060 
    """
3061 
    self.send_toggleDOAFlag(orderId)
3062 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3063 
 
2536 chandransh 3064 
  def send_toggleDOAFlag(self, orderId):
3065 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3066 
    args = toggleDOAFlag_args()
3067 
    args.orderId = orderId
3068 
    args.write(self._oprot)
3069 
    self._oprot.writeMessageEnd()
3070 
    self._oprot.trans.flush()
3071 
 
3072 
  def recv_toggleDOAFlag(self, ):
3073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3074 
    if mtype == TMessageType.EXCEPTION:
3075 
      x = TApplicationException()
3076 
      x.read(self._iprot)
3077 
      self._iprot.readMessageEnd()
3078 
      raise x
3079 
    result = toggleDOAFlag_result()
3080 
    result.read(self._iprot)
3081 
    self._iprot.readMessageEnd()
3431 rajveer 3082 
    if result.success is not None:
2536 chandransh 3083 
      return result.success
3431 rajveer 3084 
    if result.ex is not None:
2536 chandransh 3085 
      raise result.ex
3086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3087 
 
4712 rajveer 3088 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3089 
    """
3090 
    Parameters:
3091 
     - orderId
3092 
     - deliveryTimestamp
3093 
     - receiver
3094 
    """
3095 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3096 
    self.recv_markOrderAsDelivered()
3097 
 
3098 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3099 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3100 
    args = markOrderAsDelivered_args()
3101 
    args.orderId = orderId
3102 
    args.deliveryTimestamp = deliveryTimestamp
3103 
    args.receiver = receiver
3104 
    args.write(self._oprot)
3105 
    self._oprot.writeMessageEnd()
3106 
    self._oprot.trans.flush()
3107 
 
3108 
  def recv_markOrderAsDelivered(self, ):
3109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3110 
    if mtype == TMessageType.EXCEPTION:
3111 
      x = TApplicationException()
3112 
      x.read(self._iprot)
3113 
      self._iprot.readMessageEnd()
3114 
      raise x
3115 
    result = markOrderAsDelivered_result()
3116 
    result.read(self._iprot)
3117 
    self._iprot.readMessageEnd()
3118 
    if result.ex is not None:
3119 
      raise result.ex
3120 
    return
3121 
 
5553 rajveer 3122 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3123 
    """
3124 
    Parameters:
3125 
     - orderId
3126 
     - deliveryTimestamp
3127 
    """
3128 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3129 
    self.recv_markOrderAsReceivedAtStore()
3130 
 
3131 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3132 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3133 
    args = markOrderAsReceivedAtStore_args()
3134 
    args.orderId = orderId
3135 
    args.deliveryTimestamp = deliveryTimestamp
3136 
    args.write(self._oprot)
3137 
    self._oprot.writeMessageEnd()
3138 
    self._oprot.trans.flush()
3139 
 
3140 
  def recv_markOrderAsReceivedAtStore(self, ):
3141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3142 
    if mtype == TMessageType.EXCEPTION:
3143 
      x = TApplicationException()
3144 
      x.read(self._iprot)
3145 
      self._iprot.readMessageEnd()
3146 
      raise x
3147 
    result = markOrderAsReceivedAtStore_result()
3148 
    result.read(self._iprot)
3149 
    self._iprot.readMessageEnd()
3150 
    if result.ex is not None:
3151 
      raise result.ex
3152 
    return
3153 
 
4454 rajveer 3154 
  def markOrderDoaRequestReceived(self, orderId):
3155 
    """
3156 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3157 
 
3158 
    Parameters:
3159 
     - orderId
3160 
    """
3161 
    self.send_markOrderDoaRequestReceived(orderId)
3162 
    return self.recv_markOrderDoaRequestReceived()
3163 
 
3164 
  def send_markOrderDoaRequestReceived(self, orderId):
3165 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3166 
    args = markOrderDoaRequestReceived_args()
3167 
    args.orderId = orderId
3168 
    args.write(self._oprot)
3169 
    self._oprot.writeMessageEnd()
3170 
    self._oprot.trans.flush()
3171 
 
3172 
  def recv_markOrderDoaRequestReceived(self, ):
3173 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3174 
    if mtype == TMessageType.EXCEPTION:
3175 
      x = TApplicationException()
3176 
      x.read(self._iprot)
3177 
      self._iprot.readMessageEnd()
3178 
      raise x
3179 
    result = markOrderDoaRequestReceived_result()
3180 
    result.read(self._iprot)
3181 
    self._iprot.readMessageEnd()
3182 
    if result.success is not None:
3183 
      return result.success
3184 
    if result.ex is not None:
3185 
      raise result.ex
3186 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3187 
 
3188 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3189 
    """
3190 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3191 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3192 
 
3193 
    Parameters:
3194 
     - orderId
3195 
     - isAuthorized
3196 
    """
3197 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3198 
    return self.recv_markOrderDoaRequestAuthorized()
3199 
 
3200 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3201 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3202 
    args = markOrderDoaRequestAuthorized_args()
3203 
    args.orderId = orderId
3204 
    args.isAuthorized = isAuthorized
3205 
    args.write(self._oprot)
3206 
    self._oprot.writeMessageEnd()
3207 
    self._oprot.trans.flush()
3208 
 
3209 
  def recv_markOrderDoaRequestAuthorized(self, ):
3210 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3211 
    if mtype == TMessageType.EXCEPTION:
3212 
      x = TApplicationException()
3213 
      x.read(self._iprot)
3214 
      self._iprot.readMessageEnd()
3215 
      raise x
3216 
    result = markOrderDoaRequestAuthorized_result()
3217 
    result.read(self._iprot)
3218 
    self._iprot.readMessageEnd()
3219 
    if result.success is not None:
3220 
      return result.success
3221 
    if result.ex is not None:
3222 
      raise result.ex
3223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3224 
 
4488 rajveer 3225 
  def markOrderReturnRequestReceived(self, orderId):
3226 
    """
3227 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3228 
 
3229 
    Parameters:
3230 
     - orderId
3231 
    """
3232 
    self.send_markOrderReturnRequestReceived(orderId)
3233 
    return self.recv_markOrderReturnRequestReceived()
3234 
 
3235 
  def send_markOrderReturnRequestReceived(self, orderId):
3236 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3237 
    args = markOrderReturnRequestReceived_args()
3238 
    args.orderId = orderId
3239 
    args.write(self._oprot)
3240 
    self._oprot.writeMessageEnd()
3241 
    self._oprot.trans.flush()
3242 
 
3243 
  def recv_markOrderReturnRequestReceived(self, ):
3244 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3245 
    if mtype == TMessageType.EXCEPTION:
3246 
      x = TApplicationException()
3247 
      x.read(self._iprot)
3248 
      self._iprot.readMessageEnd()
3249 
      raise x
3250 
    result = markOrderReturnRequestReceived_result()
3251 
    result.read(self._iprot)
3252 
    self._iprot.readMessageEnd()
3253 
    if result.success is not None:
3254 
      return result.success
3255 
    if result.ex is not None:
3256 
      raise result.ex
3257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3258 
 
3259 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3260 
    """
3261 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3262 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3263 
 
3264 
    Parameters:
3265 
     - orderId
3266 
     - isAuthorized
3267 
    """
3268 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3269 
    return self.recv_markOrderReturnRequestAuthorized()
3270 
 
3271 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3272 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3273 
    args = markOrderReturnRequestAuthorized_args()
3274 
    args.orderId = orderId
3275 
    args.isAuthorized = isAuthorized
3276 
    args.write(self._oprot)
3277 
    self._oprot.writeMessageEnd()
3278 
    self._oprot.trans.flush()
3279 
 
3280 
  def recv_markOrderReturnRequestAuthorized(self, ):
3281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3282 
    if mtype == TMessageType.EXCEPTION:
3283 
      x = TApplicationException()
3284 
      x.read(self._iprot)
3285 
      self._iprot.readMessageEnd()
3286 
      raise x
3287 
    result = markOrderReturnRequestAuthorized_result()
3288 
    result.read(self._iprot)
3289 
    self._iprot.readMessageEnd()
3290 
    if result.success is not None:
3291 
      return result.success
3292 
    if result.ex is not None:
3293 
      raise result.ex
3294 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3295 
 
4579 rajveer 3296 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3297 
    """
3298 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3299 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3300 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3301 
    For any other status, it returns false.
3302 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3303 
 
2536 chandransh 3304 
    Parameters:
3305 
     - orderId
4579 rajveer 3306 
     - providerId
2536 chandransh 3307 
    """
4579 rajveer 3308 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3309 
    return self.recv_requestPickupNumber()
3310 
 
4579 rajveer 3311 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3312 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3313 
    args = requestPickupNumber_args()
3314 
    args.orderId = orderId
4579 rajveer 3315 
    args.providerId = providerId
2536 chandransh 3316 
    args.write(self._oprot)
3317 
    self._oprot.writeMessageEnd()
3318 
    self._oprot.trans.flush()
3319 
 
3320 
  def recv_requestPickupNumber(self, ):
3321 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3322 
    if mtype == TMessageType.EXCEPTION:
3323 
      x = TApplicationException()
3324 
      x.read(self._iprot)
3325 
      self._iprot.readMessageEnd()
3326 
      raise x
3327 
    result = requestPickupNumber_result()
3328 
    result.read(self._iprot)
3329 
    self._iprot.readMessageEnd()
3431 rajveer 3330 
    if result.success is not None:
2536 chandransh 3331 
      return result.success
3431 rajveer 3332 
    if result.ex is not None:
2536 chandransh 3333 
      raise result.ex
3334 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3335 
 
4602 rajveer 3336 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3337 
    """
4452 rajveer 3338 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3339 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3340 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3341 
    	3. Returns true
2591 chandransh 3342 
    If the order is in any other status, it returns false.
2536 chandransh 3343 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3344 
 
2536 chandransh 3345 
    Parameters:
3346 
     - orderId
3347 
     - pickupNumber
4602 rajveer 3348 
     - providerId
2536 chandransh 3349 
    """
4602 rajveer 3350 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3351 
    return self.recv_authorizePickup()
3352 
 
4602 rajveer 3353 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3354 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3355 
    args = authorizePickup_args()
3356 
    args.orderId = orderId
3357 
    args.pickupNumber = pickupNumber
4602 rajveer 3358 
    args.providerId = providerId
2536 chandransh 3359 
    args.write(self._oprot)
3360 
    self._oprot.writeMessageEnd()
3361 
    self._oprot.trans.flush()
3362 
 
3363 
  def recv_authorizePickup(self, ):
3364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3365 
    if mtype == TMessageType.EXCEPTION:
3366 
      x = TApplicationException()
3367 
      x.read(self._iprot)
3368 
      self._iprot.readMessageEnd()
3369 
      raise x
3370 
    result = authorizePickup_result()
3371 
    result.read(self._iprot)
3372 
    self._iprot.readMessageEnd()
3431 rajveer 3373 
    if result.success is not None:
2536 chandransh 3374 
      return result.success
3431 rajveer 3375 
    if result.ex is not None:
2536 chandransh 3376 
      raise result.ex
3377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3378 
 
2764 chandransh 3379 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3380 
    """
3381 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3382 
 
2764 chandransh 3383 
    Parameters:
3384 
     - providerId
3385 
     - pickupDetails
3386 
    """
3387 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3388 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3389 
 
3390 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3391 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3392 
    args = markDoasAsPickedUp_args()
3393 
    args.providerId = providerId
3394 
    args.pickupDetails = pickupDetails
3395 
    args.write(self._oprot)
3396 
    self._oprot.writeMessageEnd()
3397 
    self._oprot.trans.flush()
3398 
 
3399 
  def recv_markDoasAsPickedUp(self, ):
3400 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3401 
    if mtype == TMessageType.EXCEPTION:
3402 
      x = TApplicationException()
3403 
      x.read(self._iprot)
3404 
      self._iprot.readMessageEnd()
3405 
      raise x
3406 
    result = markDoasAsPickedUp_result()
3407 
    result.read(self._iprot)
3408 
    self._iprot.readMessageEnd()
4910 phani.kuma 3409 
    return
3410 
 
3411 
  def getDoasNotPickedUp(self, providerId):
3412 
    """
3413 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3414 
 
3415 
    Parameters:
3416 
     - providerId
3417 
    """
3418 
    self.send_getDoasNotPickedUp(providerId)
3419 
    return self.recv_getDoasNotPickedUp()
3420 
 
3421 
  def send_getDoasNotPickedUp(self, providerId):
3422 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3423 
    args = getDoasNotPickedUp_args()
3424 
    args.providerId = providerId
3425 
    args.write(self._oprot)
3426 
    self._oprot.writeMessageEnd()
3427 
    self._oprot.trans.flush()
3428 
 
3429 
  def recv_getDoasNotPickedUp(self, ):
3430 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3431 
    if mtype == TMessageType.EXCEPTION:
3432 
      x = TApplicationException()
3433 
      x.read(self._iprot)
3434 
      self._iprot.readMessageEnd()
3435 
      raise x
3436 
    result = getDoasNotPickedUp_result()
3437 
    result.read(self._iprot)
3438 
    self._iprot.readMessageEnd()
3431 rajveer 3439 
    if result.success is not None:
2764 chandransh 3440 
      return result.success
4910 phani.kuma 3441 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3442 
 
4741 phani.kuma 3443 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3444 
    """
3445 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3446 
 
3447 
    Parameters:
3448 
     - providerId
3449 
     - pickupDetails
3450 
    """
3451 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3452 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3453 
 
3454 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3455 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3456 
    args = markReturnOrdersAsPickedUp_args()
3457 
    args.providerId = providerId
3458 
    args.pickupDetails = pickupDetails
3459 
    args.write(self._oprot)
3460 
    self._oprot.writeMessageEnd()
3461 
    self._oprot.trans.flush()
3462 
 
3463 
  def recv_markReturnOrdersAsPickedUp(self, ):
3464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3465 
    if mtype == TMessageType.EXCEPTION:
3466 
      x = TApplicationException()
3467 
      x.read(self._iprot)
3468 
      self._iprot.readMessageEnd()
3469 
      raise x
3470 
    result = markReturnOrdersAsPickedUp_result()
3471 
    result.read(self._iprot)
3472 
    self._iprot.readMessageEnd()
4910 phani.kuma 3473 
    return
3474 
 
3475 
  def getReturnOrdersNotPickedUp(self, providerId):
3476 
    """
3477 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3478 
 
3479 
    Parameters:
3480 
     - providerId
3481 
    """
3482 
    self.send_getReturnOrdersNotPickedUp(providerId)
3483 
    return self.recv_getReturnOrdersNotPickedUp()
3484 
 
3485 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3486 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3487 
    args = getReturnOrdersNotPickedUp_args()
3488 
    args.providerId = providerId
3489 
    args.write(self._oprot)
3490 
    self._oprot.writeMessageEnd()
3491 
    self._oprot.trans.flush()
3492 
 
3493 
  def recv_getReturnOrdersNotPickedUp(self, ):
3494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3495 
    if mtype == TMessageType.EXCEPTION:
3496 
      x = TApplicationException()
3497 
      x.read(self._iprot)
3498 
      self._iprot.readMessageEnd()
3499 
      raise x
3500 
    result = getReturnOrdersNotPickedUp_result()
3501 
    result.read(self._iprot)
3502 
    self._iprot.readMessageEnd()
4741 phani.kuma 3503 
    if result.success is not None:
3504 
      return result.success
4910 phani.kuma 3505 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3506 
 
4479 rajveer 3507 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3508 
    """
4452 rajveer 3509 
    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 3510 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3511 
    If the order is in any other state, it returns false.
3512 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3513 
 
2591 chandransh 3514 
    Parameters:
3515 
     - orderId
4479 rajveer 3516 
     - receiveCondition
2591 chandransh 3517 
    """
4479 rajveer 3518 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3519 
    return self.recv_receiveReturn()
2536 chandransh 3520 
 
4479 rajveer 3521 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3522 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3523 
    args = receiveReturn_args()
2591 chandransh 3524 
    args.orderId = orderId
4479 rajveer 3525 
    args.receiveCondition = receiveCondition
2591 chandransh 3526 
    args.write(self._oprot)
3527 
    self._oprot.writeMessageEnd()
3528 
    self._oprot.trans.flush()
3529 
 
2616 chandransh 3530 
  def recv_receiveReturn(self, ):
2591 chandransh 3531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3532 
    if mtype == TMessageType.EXCEPTION:
3533 
      x = TApplicationException()
3534 
      x.read(self._iprot)
3535 
      self._iprot.readMessageEnd()
3536 
      raise x
2616 chandransh 3537 
    result = receiveReturn_result()
2591 chandransh 3538 
    result.read(self._iprot)
3539 
    self._iprot.readMessageEnd()
3431 rajveer 3540 
    if result.success is not None:
2591 chandransh 3541 
      return result.success
3431 rajveer 3542 
    if result.ex is not None:
2591 chandransh 3543 
      raise result.ex
2616 chandransh 3544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3545 
 
3546 
  def validateDoa(self, orderId, isValid):
3547 
    """
4452 rajveer 3548 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3549 
    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 3550 
    If the order is in any other state, it returns false.
3551 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3552 
 
2591 chandransh 3553 
    Parameters:
3554 
     - orderId
3555 
     - isValid
3556 
    """
3557 
    self.send_validateDoa(orderId, isValid)
3558 
    return self.recv_validateDoa()
3559 
 
3560 
  def send_validateDoa(self, orderId, isValid):
3561 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3562 
    args = validateDoa_args()
3563 
    args.orderId = orderId
3564 
    args.isValid = isValid
3565 
    args.write(self._oprot)
3566 
    self._oprot.writeMessageEnd()
3567 
    self._oprot.trans.flush()
3568 
 
3569 
  def recv_validateDoa(self, ):
3570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3571 
    if mtype == TMessageType.EXCEPTION:
3572 
      x = TApplicationException()
3573 
      x.read(self._iprot)
3574 
      self._iprot.readMessageEnd()
3575 
      raise x
3576 
    result = validateDoa_result()
3577 
    result.read(self._iprot)
3578 
    self._iprot.readMessageEnd()
3431 rajveer 3579 
    if result.success is not None:
2591 chandransh 3580 
      return result.success
3431 rajveer 3581 
    if result.ex is not None:
2591 chandransh 3582 
      raise result.ex
3583 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3584 
 
4495 rajveer 3585 
  def validateReturnProduct(self, orderId, isUsable):
3586 
    """
3587 
    Parameters:
3588 
     - orderId
3589 
     - isUsable
3590 
    """
3591 
    self.send_validateReturnProduct(orderId, isUsable)
3592 
    return self.recv_validateReturnProduct()
3593 
 
3594 
  def send_validateReturnProduct(self, orderId, isUsable):
3595 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3596 
    args = validateReturnProduct_args()
3597 
    args.orderId = orderId
3598 
    args.isUsable = isUsable
3599 
    args.write(self._oprot)
3600 
    self._oprot.writeMessageEnd()
3601 
    self._oprot.trans.flush()
3602 
 
3603 
  def recv_validateReturnProduct(self, ):
3604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3605 
    if mtype == TMessageType.EXCEPTION:
3606 
      x = TApplicationException()
3607 
      x.read(self._iprot)
3608 
      self._iprot.readMessageEnd()
3609 
      raise x
3610 
    result = validateReturnProduct_result()
3611 
    result.read(self._iprot)
3612 
    self._iprot.readMessageEnd()
3613 
    if result.success is not None:
3614 
      return result.success
3615 
    if result.ex is not None:
3616 
      raise result.ex
3617 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3618 
 
2616 chandransh 3619 
  def reshipOrder(self, orderId):
3620 
    """
4484 rajveer 3621 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3622 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3623 
    	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 3624 
 
3625 
    If the order is in DOA_CERT_VALID state, it does the following:
3626 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3627 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3628 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3629 
 
2616 chandransh 3630 
    Returns the id of the newly created order.
3431 rajveer 3631 
 
2616 chandransh 3632 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3633 
 
2616 chandransh 3634 
    Parameters:
3635 
     - orderId
3636 
    """
3637 
    self.send_reshipOrder(orderId)
3638 
    return self.recv_reshipOrder()
2591 chandransh 3639 
 
2616 chandransh 3640 
  def send_reshipOrder(self, orderId):
3641 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3642 
    args = reshipOrder_args()
3643 
    args.orderId = orderId
3644 
    args.write(self._oprot)
3645 
    self._oprot.writeMessageEnd()
3646 
    self._oprot.trans.flush()
3647 
 
3648 
  def recv_reshipOrder(self, ):
3649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3650 
    if mtype == TMessageType.EXCEPTION:
3651 
      x = TApplicationException()
3652 
      x.read(self._iprot)
3653 
      self._iprot.readMessageEnd()
3654 
      raise x
3655 
    result = reshipOrder_result()
3656 
    result.read(self._iprot)
3657 
    self._iprot.readMessageEnd()
3431 rajveer 3658 
    if result.success is not None:
2616 chandransh 3659 
      return result.success
3431 rajveer 3660 
    if result.ex is not None:
2616 chandransh 3661 
      raise result.ex
3662 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3663 
 
3226 chandransh 3664 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3665 
    """
4484 rajveer 3666 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3667 
    	1. Creates a refund request for batch processing.
3668 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3669 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3670 
 
2616 chandransh 3671 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3672 
    	1. Creates a refund request for batch processing.
3226 chandransh 3673 
    	2. Cancels the reservation of the item in the warehouse.
3674 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3675 
 
3226 chandransh 3676 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3677 
    	1. Cancels the reservation of the item in the warehouse.
3678 
    	2. Marks the current order as CANCELED.
3679 
 
3680 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3681 
 
2616 chandransh 3682 
    Returns True if it is successful, False otherwise.
3431 rajveer 3683 
 
2616 chandransh 3684 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3685 
 
2616 chandransh 3686 
    Parameters:
3687 
     - orderId
3226 chandransh 3688 
     - refundedBy
3689 
     - reason
2616 chandransh 3690 
    """
3226 chandransh 3691 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3692 
    return self.recv_refundOrder()
3693 
 
3226 chandransh 3694 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3695 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3696 
    args = refundOrder_args()
3697 
    args.orderId = orderId
3226 chandransh 3698 
    args.refundedBy = refundedBy
3699 
    args.reason = reason
2616 chandransh 3700 
    args.write(self._oprot)
3701 
    self._oprot.writeMessageEnd()
3702 
    self._oprot.trans.flush()
3703 
 
3704 
  def recv_refundOrder(self, ):
3705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3706 
    if mtype == TMessageType.EXCEPTION:
3707 
      x = TApplicationException()
3708 
      x.read(self._iprot)
3709 
      self._iprot.readMessageEnd()
3710 
      raise x
3711 
    result = refundOrder_result()
3712 
    result.read(self._iprot)
3713 
    self._iprot.readMessageEnd()
3431 rajveer 3714 
    if result.success is not None:
2616 chandransh 3715 
      return result.success
3431 rajveer 3716 
    if result.ex is not None:
2616 chandransh 3717 
      raise result.ex
3718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3719 
 
2690 chandransh 3720 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3721 
    """
3722 
    Get all return orders created between the from and to dates for the given warehouse.
3723 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3724 
 
2690 chandransh 3725 
    Parameters:
3726 
     - warehouseId
3727 
     - fromDate
3728 
     - toDate
3729 
    """
3730 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3731 
    return self.recv_getReturnOrders()
2616 chandransh 3732 
 
2690 chandransh 3733 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3734 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3735 
    args = getReturnOrders_args()
3736 
    args.warehouseId = warehouseId
3737 
    args.fromDate = fromDate
3738 
    args.toDate = toDate
3739 
    args.write(self._oprot)
3740 
    self._oprot.writeMessageEnd()
3741 
    self._oprot.trans.flush()
3742 
 
3743 
  def recv_getReturnOrders(self, ):
3744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3745 
    if mtype == TMessageType.EXCEPTION:
3746 
      x = TApplicationException()
3747 
      x.read(self._iprot)
3748 
      self._iprot.readMessageEnd()
3749 
      raise x
3750 
    result = getReturnOrders_result()
3751 
    result.read(self._iprot)
3752 
    self._iprot.readMessageEnd()
3431 rajveer 3753 
    if result.success is not None:
2690 chandransh 3754 
      return result.success
3755 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3756 
 
5481 phani.kuma 3757 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3758 
    """
3759 
    Get all return orders created between the from and to dates.
3760 
 
3761 
    Parameters:
3762 
     - onlyNotProcessed
3763 
     - fromDate
3764 
     - toDate
3765 
    """
3766 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3767 
    return self.recv_getAllReturnOrders()
3768 
 
3769 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3770 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3771 
    args = getAllReturnOrders_args()
3772 
    args.onlyNotProcessed = onlyNotProcessed
3773 
    args.fromDate = fromDate
3774 
    args.toDate = toDate
3775 
    args.write(self._oprot)
3776 
    self._oprot.writeMessageEnd()
3777 
    self._oprot.trans.flush()
3778 
 
3779 
  def recv_getAllReturnOrders(self, ):
3780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3781 
    if mtype == TMessageType.EXCEPTION:
3782 
      x = TApplicationException()
3783 
      x.read(self._iprot)
3784 
      self._iprot.readMessageEnd()
3785 
      raise x
3786 
    result = getAllReturnOrders_result()
3787 
    result.read(self._iprot)
3788 
    self._iprot.readMessageEnd()
3789 
    if result.success is not None:
3790 
      return result.success
3791 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3792 
 
2700 chandransh 3793 
  def getReturnOrder(self, id):
3794 
    """
3795 
    Returns the ReturnOrder corresponding to the given id.
3796 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3797 
 
2700 chandransh 3798 
    Parameters:
3799 
     - id
3800 
    """
3801 
    self.send_getReturnOrder(id)
3802 
    return self.recv_getReturnOrder()
3803 
 
3804 
  def send_getReturnOrder(self, id):
3805 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3806 
    args = getReturnOrder_args()
3807 
    args.id = id
3808 
    args.write(self._oprot)
3809 
    self._oprot.writeMessageEnd()
3810 
    self._oprot.trans.flush()
3811 
 
3812 
  def recv_getReturnOrder(self, ):
3813 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3814 
    if mtype == TMessageType.EXCEPTION:
3815 
      x = TApplicationException()
3816 
      x.read(self._iprot)
3817 
      self._iprot.readMessageEnd()
3818 
      raise x
3819 
    result = getReturnOrder_result()
3820 
    result.read(self._iprot)
3821 
    self._iprot.readMessageEnd()
3431 rajveer 3822 
    if result.success is not None:
2700 chandransh 3823 
      return result.success
3431 rajveer 3824 
    if result.ex is not None:
2700 chandransh 3825 
      raise result.ex
3826 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3827 
 
2690 chandransh 3828 
  def processReturn(self, returnOrderId):
3829 
    """
3830 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3831 
 
2690 chandransh 3832 
    Parameters:
3833 
     - returnOrderId
3834 
    """
3835 
    self.send_processReturn(returnOrderId)
3836 
    self.recv_processReturn()
3837 
 
3838 
  def send_processReturn(self, returnOrderId):
3839 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3840 
    args = processReturn_args()
3841 
    args.returnOrderId = returnOrderId
3842 
    args.write(self._oprot)
3843 
    self._oprot.writeMessageEnd()
3844 
    self._oprot.trans.flush()
3845 
 
3846 
  def recv_processReturn(self, ):
3847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3848 
    if mtype == TMessageType.EXCEPTION:
3849 
      x = TApplicationException()
3850 
      x.read(self._iprot)
3851 
      self._iprot.readMessageEnd()
3852 
      raise x
3853 
    result = processReturn_result()
3854 
    result.read(self._iprot)
3855 
    self._iprot.readMessageEnd()
3431 rajveer 3856 
    if result.ex is not None:
2690 chandransh 3857 
      raise result.ex
3858 
    return
3859 
 
3451 chandransh 3860 
  def updateWeight(self, orderId, weight):
3861 
    """
3862 
    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 3863 
 
3451 chandransh 3864 
    Parameters:
3865 
     - orderId
3866 
     - weight
3867 
    """
3868 
    self.send_updateWeight(orderId, weight)
3869 
    return self.recv_updateWeight()
3870 
 
3871 
  def send_updateWeight(self, orderId, weight):
3872 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3873 
    args = updateWeight_args()
3874 
    args.orderId = orderId
3875 
    args.weight = weight
3876 
    args.write(self._oprot)
3877 
    self._oprot.writeMessageEnd()
3878 
    self._oprot.trans.flush()
3879 
 
3880 
  def recv_updateWeight(self, ):
3881 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3882 
    if mtype == TMessageType.EXCEPTION:
3883 
      x = TApplicationException()
3884 
      x.read(self._iprot)
3885 
      self._iprot.readMessageEnd()
3886 
      raise x
3887 
    result = updateWeight_result()
3888 
    result.read(self._iprot)
3889 
    self._iprot.readMessageEnd()
3890 
    if result.success is not None:
3891 
      return result.success
3892 
    if result.ex is not None:
3893 
      raise result.ex
3894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
3895 
 
3469 chandransh 3896 
  def changeItem(self, orderId, itemId):
3897 
    """
3898 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
3899 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 3900 
 
3469 chandransh 3901 
    Parameters:
3902 
     - orderId
3903 
     - itemId
3904 
    """
3905 
    self.send_changeItem(orderId, itemId)
3906 
    return self.recv_changeItem()
3907 
 
3908 
  def send_changeItem(self, orderId, itemId):
3909 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
3910 
    args = changeItem_args()
3911 
    args.orderId = orderId
3912 
    args.itemId = itemId
3913 
    args.write(self._oprot)
3914 
    self._oprot.writeMessageEnd()
3915 
    self._oprot.trans.flush()
3916 
 
3917 
  def recv_changeItem(self, ):
3918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3919 
    if mtype == TMessageType.EXCEPTION:
3920 
      x = TApplicationException()
3921 
      x.read(self._iprot)
3922 
      self._iprot.readMessageEnd()
3923 
      raise x
3924 
    result = changeItem_result()
3925 
    result.read(self._iprot)
3926 
    self._iprot.readMessageEnd()
3927 
    if result.success is not None:
3928 
      return result.success
3929 
    if result.ex is not None:
3930 
      raise result.ex
3931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
3932 
 
3933 
  def shiftToWarehouse(self, orderId, warehouseId):
3934 
    """
3935 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
3936 
 
3937 
    Parameters:
3938 
     - orderId
3939 
     - warehouseId
3940 
    """
3941 
    self.send_shiftToWarehouse(orderId, warehouseId)
3942 
    return self.recv_shiftToWarehouse()
3943 
 
3944 
  def send_shiftToWarehouse(self, orderId, warehouseId):
3945 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
3946 
    args = shiftToWarehouse_args()
3947 
    args.orderId = orderId
3948 
    args.warehouseId = warehouseId
3949 
    args.write(self._oprot)
3950 
    self._oprot.writeMessageEnd()
3951 
    self._oprot.trans.flush()
3952 
 
3953 
  def recv_shiftToWarehouse(self, ):
3954 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3955 
    if mtype == TMessageType.EXCEPTION:
3956 
      x = TApplicationException()
3957 
      x.read(self._iprot)
3958 
      self._iprot.readMessageEnd()
3959 
      raise x
3960 
    result = shiftToWarehouse_result()
3961 
    result.read(self._iprot)
3962 
    self._iprot.readMessageEnd()
3963 
    if result.success is not None:
3964 
      return result.success
3965 
    if result.ex is not None:
3966 
      raise result.ex
3967 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
3968 
 
4647 rajveer 3969 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3970 
    """
3971 
    Adds the given delay reason to the given order.
3986 chandransh 3972 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 3973 
    Raises an exception if no order with the given id can be found.
3469 chandransh 3974 
 
3553 chandransh 3975 
    Parameters:
3976 
     - orderId
3977 
     - delayReason
3986 chandransh 3978 
     - furtherDelay
4647 rajveer 3979 
     - delayReasonText
3553 chandransh 3980 
    """
4647 rajveer 3981 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 3982 
    return self.recv_addDelayReason()
3983 
 
4647 rajveer 3984 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 3985 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
3986 
    args = addDelayReason_args()
3987 
    args.orderId = orderId
3988 
    args.delayReason = delayReason
3986 chandransh 3989 
    args.furtherDelay = furtherDelay
4647 rajveer 3990 
    args.delayReasonText = delayReasonText
3553 chandransh 3991 
    args.write(self._oprot)
3992 
    self._oprot.writeMessageEnd()
3993 
    self._oprot.trans.flush()
3994 
 
3995 
  def recv_addDelayReason(self, ):
3996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3997 
    if mtype == TMessageType.EXCEPTION:
3998 
      x = TApplicationException()
3999 
      x.read(self._iprot)
4000 
      self._iprot.readMessageEnd()
4001 
      raise x
4002 
    result = addDelayReason_result()
4003 
    result.read(self._iprot)
4004 
    self._iprot.readMessageEnd()
4005 
    if result.success is not None:
4006 
      return result.success
4007 
    if result.ex is not None:
4008 
      raise result.ex
4009 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4010 
 
3956 chandransh 4011 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4012 
    """
4013 
    Marks the COD orders with given AWB nos. as having been processed.
4014 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4015 
 
3956 chandransh 4016 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4017 
    1. There is no order corresponding to an AWB number.
4018 
    2. The captured amount for a payment exceeds the total payment.
4019 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4020 
 
4021 
    Parameters:
4022 
     - collectedAmountMap
4023 
     - xferBy
4024 
     - xferTxnId
4025 
     - xferDate
4026 
    """
4027 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4028 
    return self.recv_reconcileCodCollection()
4029 
 
4030 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4031 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4032 
    args = reconcileCodCollection_args()
4033 
    args.collectedAmountMap = collectedAmountMap
4034 
    args.xferBy = xferBy
4035 
    args.xferTxnId = xferTxnId
4036 
    args.xferDate = xferDate
4037 
    args.write(self._oprot)
4038 
    self._oprot.writeMessageEnd()
4039 
    self._oprot.trans.flush()
4040 
 
4041 
  def recv_reconcileCodCollection(self, ):
4042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4043 
    if mtype == TMessageType.EXCEPTION:
4044 
      x = TApplicationException()
4045 
      x.read(self._iprot)
4046 
      self._iprot.readMessageEnd()
4047 
      raise x
4048 
    result = reconcileCodCollection_result()
4049 
    result.read(self._iprot)
4050 
    self._iprot.readMessageEnd()
4051 
    if result.success is not None:
4052 
      return result.success
4053 
    if result.ex is not None:
4054 
      raise result.ex
4055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4056 
 
4008 mandeep.dh 4057 
  def getTransactionsRequiringExtraProcessing(self, category):
4058 
    """
4065 mandeep.dh 4059 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4060 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4061 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4062 
 
4008 mandeep.dh 4063 
    Parameters:
4064 
     - category
4065 
    """
4066 
    self.send_getTransactionsRequiringExtraProcessing(category)
4067 
    return self.recv_getTransactionsRequiringExtraProcessing()
4068 
 
4069 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4070 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4071 
    args = getTransactionsRequiringExtraProcessing_args()
4072 
    args.category = category
4073 
    args.write(self._oprot)
4074 
    self._oprot.writeMessageEnd()
4075 
    self._oprot.trans.flush()
4076 
 
4077 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4079 
    if mtype == TMessageType.EXCEPTION:
4080 
      x = TApplicationException()
4081 
      x.read(self._iprot)
4082 
      self._iprot.readMessageEnd()
4083 
      raise x
4084 
    result = getTransactionsRequiringExtraProcessing_result()
4085 
    result.read(self._iprot)
4086 
    self._iprot.readMessageEnd()
4087 
    if result.success is not None:
4088 
      return result.success
4089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4090 
 
4091 
  def markTransactionAsProcessed(self, transactionId, category):
4092 
    """
4093 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4094 
    It essentially deletes the transaction id record for a particular
4095 
    processing type category (if present) from DB.
4096 
    This is currently used by CRM application.
4008 mandeep.dh 4097 
 
4098 
    Parameters:
4099 
     - transactionId
4100 
     - category
4101 
    """
4102 
    self.send_markTransactionAsProcessed(transactionId, category)
4103 
    self.recv_markTransactionAsProcessed()
4104 
 
4105 
  def send_markTransactionAsProcessed(self, transactionId, category):
4106 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4107 
    args = markTransactionAsProcessed_args()
4108 
    args.transactionId = transactionId
4109 
    args.category = category
4110 
    args.write(self._oprot)
4111 
    self._oprot.writeMessageEnd()
4112 
    self._oprot.trans.flush()
4113 
 
4114 
  def recv_markTransactionAsProcessed(self, ):
4115 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4116 
    if mtype == TMessageType.EXCEPTION:
4117 
      x = TApplicationException()
4118 
      x.read(self._iprot)
4119 
      self._iprot.readMessageEnd()
4120 
      raise x
4121 
    result = markTransactionAsProcessed_result()
4122 
    result.read(self._iprot)
4123 
    self._iprot.readMessageEnd()
4124 
    return
4125 
 
4018 chandransh 4126 
  def getItemWiseRiskyOrdersCount(self, ):
4127 
    """
4128 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4129 
    is defined as one whose shipping date is about to expire.
4130 
    """
4131 
    self.send_getItemWiseRiskyOrdersCount()
4132 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4133 
 
4018 chandransh 4134 
  def send_getItemWiseRiskyOrdersCount(self, ):
4135 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4136 
    args = getItemWiseRiskyOrdersCount_args()
4137 
    args.write(self._oprot)
4138 
    self._oprot.writeMessageEnd()
4139 
    self._oprot.trans.flush()
4140 
 
4141 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4143 
    if mtype == TMessageType.EXCEPTION:
4144 
      x = TApplicationException()
4145 
      x.read(self._iprot)
4146 
      self._iprot.readMessageEnd()
4147 
      raise x
4148 
    result = getItemWiseRiskyOrdersCount_result()
4149 
    result.read(self._iprot)
4150 
    self._iprot.readMessageEnd()
4151 
    if result.success is not None:
4152 
      return result.success
4153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4154 
 
4295 varun.gupt 4155 
  def getOrdersForItemIds(self, itemIds):
4156 
    """
4157 
    Returns a list of all orders which have items with given id
4158 
 
4159 
    Parameters:
4160 
     - itemIds
4161 
    """
4162 
    self.send_getOrdersForItemIds(itemIds)
4163 
    return self.recv_getOrdersForItemIds()
4164 
 
4165 
  def send_getOrdersForItemIds(self, itemIds):
4166 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4167 
    args = getOrdersForItemIds_args()
4168 
    args.itemIds = itemIds
4169 
    args.write(self._oprot)
4170 
    self._oprot.writeMessageEnd()
4171 
    self._oprot.trans.flush()
4172 
 
4173 
  def recv_getOrdersForItemIds(self, ):
4174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4175 
    if mtype == TMessageType.EXCEPTION:
4176 
      x = TApplicationException()
4177 
      x.read(self._iprot)
4178 
      self._iprot.readMessageEnd()
4179 
      raise x
4180 
    result = getOrdersForItemIds_result()
4181 
    result.read(self._iprot)
4182 
    self._iprot.readMessageEnd()
4183 
    if result.success is not None:
4184 
      return result.success
4185 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4186 
 
4247 rajveer 4187 
  def markOrderCancellationRequestReceived(self, orderId):
4188 
    """
4189 
    Mark order as cancellation request received. If customer sends request of cancellation of
4190 
    a particular order, this method will be called. It will just change status of the order
4191 
    depending on its current status. It also records the previous status, so that we can move
4192 
    back to that status if cancellation request is denied.
4018 chandransh 4193 
 
4247 rajveer 4194 
    Parameters:
4195 
     - orderId
4196 
    """
4197 
    self.send_markOrderCancellationRequestReceived(orderId)
4198 
    self.recv_markOrderCancellationRequestReceived()
4199 
 
4200 
  def send_markOrderCancellationRequestReceived(self, orderId):
4201 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4202 
    args = markOrderCancellationRequestReceived_args()
4203 
    args.orderId = orderId
4204 
    args.write(self._oprot)
4205 
    self._oprot.writeMessageEnd()
4206 
    self._oprot.trans.flush()
4207 
 
4208 
  def recv_markOrderCancellationRequestReceived(self, ):
4209 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4210 
    if mtype == TMessageType.EXCEPTION:
4211 
      x = TApplicationException()
4212 
      x.read(self._iprot)
4213 
      self._iprot.readMessageEnd()
4214 
      raise x
4215 
    result = markOrderCancellationRequestReceived_result()
4216 
    result.read(self._iprot)
4217 
    self._iprot.readMessageEnd()
4218 
    if result.ex is not None:
4219 
      raise result.ex
4220 
    return
4221 
 
4222 
  def markOrderCancellationRequestConfirmed(self, orderId):
4223 
    """
4224 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4225 
    cancellation request confirmed. After this OM will be able to cancel the order.
4226 
 
4227 
    Parameters:
4228 
     - orderId
4229 
    """
4230 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4231 
    self.recv_markOrderCancellationRequestConfirmed()
4232 
 
4233 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4234 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4235 
    args = markOrderCancellationRequestConfirmed_args()
4236 
    args.orderId = orderId
4237 
    args.write(self._oprot)
4238 
    self._oprot.writeMessageEnd()
4239 
    self._oprot.trans.flush()
4240 
 
4241 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4242 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4243 
    if mtype == TMessageType.EXCEPTION:
4244 
      x = TApplicationException()
4245 
      x.read(self._iprot)
4246 
      self._iprot.readMessageEnd()
4247 
      raise x
4248 
    result = markOrderCancellationRequestConfirmed_result()
4249 
    result.read(self._iprot)
4250 
    self._iprot.readMessageEnd()
4251 
    if result.ex is not None:
4252 
      raise result.ex
4253 
    return
4254 
 
4255 
  def markOrderCancellationRequestDenied(self, orderId):
4256 
    """
4257 
    If we decide to not to cancel order, we will move the order ro previous status.
4258 
 
4259 
    Parameters:
4260 
     - orderId
4261 
    """
4262 
    self.send_markOrderCancellationRequestDenied(orderId)
4263 
    self.recv_markOrderCancellationRequestDenied()
4264 
 
4265 
  def send_markOrderCancellationRequestDenied(self, orderId):
4266 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4267 
    args = markOrderCancellationRequestDenied_args()
4268 
    args.orderId = orderId
4269 
    args.write(self._oprot)
4270 
    self._oprot.writeMessageEnd()
4271 
    self._oprot.trans.flush()
4272 
 
4273 
  def recv_markOrderCancellationRequestDenied(self, ):
4274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4275 
    if mtype == TMessageType.EXCEPTION:
4276 
      x = TApplicationException()
4277 
      x.read(self._iprot)
4278 
      self._iprot.readMessageEnd()
4279 
      raise x
4280 
    result = markOrderCancellationRequestDenied_result()
4281 
    result.read(self._iprot)
4282 
    self._iprot.readMessageEnd()
4283 
    if result.ex is not None:
4284 
      raise result.ex
4285 
    return
4286 
 
4258 rajveer 4287 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4288 
    """
4258 rajveer 4289 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4290 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4291 
 
4292 
    Parameters:
4258 rajveer 4293 
     - transactionId
4247 rajveer 4294 
    """
4258 rajveer 4295 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4296 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4297 
 
4258 rajveer 4298 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4299 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4300 
    args = markTransactionAsPaymentFlagRemoved_args()
4301 
    args.transactionId = transactionId
4247 rajveer 4302 
    args.write(self._oprot)
4303 
    self._oprot.writeMessageEnd()
4304 
    self._oprot.trans.flush()
4305 
 
4258 rajveer 4306 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4308 
    if mtype == TMessageType.EXCEPTION:
4309 
      x = TApplicationException()
4310 
      x.read(self._iprot)
4311 
      self._iprot.readMessageEnd()
4312 
      raise x
4258 rajveer 4313 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4314 
    result.read(self._iprot)
4315 
    self._iprot.readMessageEnd()
4316 
    if result.ex is not None:
4317 
      raise result.ex
4318 
    return
4319 
 
4259 anupam.sin 4320 
  def refundTransaction(self, transactionId, refundedBy, reason):
4321 
    """
4322 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4323 
    need to be cancelled
4247 rajveer 4324 
 
4259 anupam.sin 4325 
    Parameters:
4326 
     - transactionId
4327 
     - refundedBy
4328 
     - reason
4329 
    """
4330 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4331 
    self.recv_refundTransaction()
4332 
 
4333 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4334 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4335 
    args = refundTransaction_args()
4336 
    args.transactionId = transactionId
4337 
    args.refundedBy = refundedBy
4338 
    args.reason = reason
4339 
    args.write(self._oprot)
4340 
    self._oprot.writeMessageEnd()
4341 
    self._oprot.trans.flush()
4342 
 
4343 
  def recv_refundTransaction(self, ):
4344 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4345 
    if mtype == TMessageType.EXCEPTION:
4346 
      x = TApplicationException()
4347 
      x.read(self._iprot)
4348 
      self._iprot.readMessageEnd()
4349 
      raise x
4350 
    result = refundTransaction_result()
4351 
    result.read(self._iprot)
4352 
    self._iprot.readMessageEnd()
4353 
    if result.ex is not None:
4354 
      raise result.ex
4355 
    return
4356 
 
4324 mandeep.dh 4357 
  def updateShipmentAddress(self, orderId, addressId):
4358 
    """
4359 
    Updates shipment address of an order. Delivery and shipping date estimates
4360 
    etc. are also updated here.
4361 
 
4362 
    Throws TransactionServiceException in case address change is not
4363 
    possible due to certain reasons such as new pincode in address is
4364 
    not serviceable etc.
4365 
 
4366 
    Parameters:
4367 
     - orderId
4368 
     - addressId
4369 
    """
4370 
    self.send_updateShipmentAddress(orderId, addressId)
4371 
    self.recv_updateShipmentAddress()
4372 
 
4373 
  def send_updateShipmentAddress(self, orderId, addressId):
4374 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4375 
    args = updateShipmentAddress_args()
4376 
    args.orderId = orderId
4377 
    args.addressId = addressId
4378 
    args.write(self._oprot)
4379 
    self._oprot.writeMessageEnd()
4380 
    self._oprot.trans.flush()
4381 
 
4382 
  def recv_updateShipmentAddress(self, ):
4383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4384 
    if mtype == TMessageType.EXCEPTION:
4385 
      x = TApplicationException()
4386 
      x.read(self._iprot)
4387 
      self._iprot.readMessageEnd()
4388 
      raise x
4389 
    result = updateShipmentAddress_result()
4390 
    result.read(self._iprot)
4391 
    self._iprot.readMessageEnd()
4392 
    if result.ex is not None:
4393 
      raise result.ex
4394 
    return
4395 
 
4285 rajveer 4396 
  def acceptOrdersForItemId(self, itemId, inventory):
4397 
    """
4398 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4399 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4400 
 
4285 rajveer 4401 
    Parameters:
4402 
     - itemId
4403 
     - inventory
4404 
    """
4405 
    self.send_acceptOrdersForItemId(itemId, inventory)
4406 
    return self.recv_acceptOrdersForItemId()
4407 
 
4408 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4409 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4410 
    args = acceptOrdersForItemId_args()
4411 
    args.itemId = itemId
4412 
    args.inventory = inventory
4413 
    args.write(self._oprot)
4414 
    self._oprot.writeMessageEnd()
4415 
    self._oprot.trans.flush()
4416 
 
4417 
  def recv_acceptOrdersForItemId(self, ):
4418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4419 
    if mtype == TMessageType.EXCEPTION:
4420 
      x = TApplicationException()
4421 
      x.read(self._iprot)
4422 
      self._iprot.readMessageEnd()
4423 
      raise x
4424 
    result = acceptOrdersForItemId_result()
4425 
    result.read(self._iprot)
4426 
    self._iprot.readMessageEnd()
4427 
    if result.success is not None:
4428 
      return result.success
4429 
    if result.ex is not None:
4430 
      raise result.ex
4431 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4432 
 
4369 rajveer 4433 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4434 
    """
4435 
    Parameters:
4436 
     - vendorId
4437 
     - itemId
4438 
     - quantity
4439 
     - estimate
4369 rajveer 4440 
     - isReminder
4303 rajveer 4441 
    """
4369 rajveer 4442 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4443 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4444 
 
4369 rajveer 4445 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4446 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4447 
    args = markOrdersAsPORaised_args()
4448 
    args.vendorId = vendorId
4449 
    args.itemId = itemId
4450 
    args.quantity = quantity
4451 
    args.estimate = estimate
4369 rajveer 4452 
    args.isReminder = isReminder
4303 rajveer 4453 
    args.write(self._oprot)
4454 
    self._oprot.writeMessageEnd()
4455 
    self._oprot.trans.flush()
4456 
 
4457 
  def recv_markOrdersAsPORaised(self, ):
4458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4459 
    if mtype == TMessageType.EXCEPTION:
4460 
      x = TApplicationException()
4461 
      x.read(self._iprot)
4462 
      self._iprot.readMessageEnd()
4463 
      raise x
4464 
    result = markOrdersAsPORaised_result()
4465 
    result.read(self._iprot)
4466 
    self._iprot.readMessageEnd()
4467 
    if result.ex is not None:
4468 
      raise result.ex
4469 
    return
4470 
 
4369 rajveer 4471 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4472 
    """
4473 
    Parameters:
4474 
     - vendorId
4475 
     - itemId
4476 
     - quantity
4477 
     - estimate
4369 rajveer 4478 
     - isReminder
4303 rajveer 4479 
    """
4369 rajveer 4480 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4481 
    self.recv_markOrdersAsReversalInitiated()
4482 
 
4369 rajveer 4483 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4484 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4485 
    args = markOrdersAsReversalInitiated_args()
4486 
    args.vendorId = vendorId
4487 
    args.itemId = itemId
4488 
    args.quantity = quantity
4489 
    args.estimate = estimate
4369 rajveer 4490 
    args.isReminder = isReminder
4303 rajveer 4491 
    args.write(self._oprot)
4492 
    self._oprot.writeMessageEnd()
4493 
    self._oprot.trans.flush()
4494 
 
4495 
  def recv_markOrdersAsReversalInitiated(self, ):
4496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4497 
    if mtype == TMessageType.EXCEPTION:
4498 
      x = TApplicationException()
4499 
      x.read(self._iprot)
4500 
      self._iprot.readMessageEnd()
4501 
      raise x
4502 
    result = markOrdersAsReversalInitiated_result()
4503 
    result.read(self._iprot)
4504 
    self._iprot.readMessageEnd()
4505 
    if result.ex is not None:
4506 
      raise result.ex
4507 
    return
4508 
 
4369 rajveer 4509 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4510 
    """
4511 
    Parameters:
4512 
     - vendorId
4513 
     - itemId
4514 
     - quantity
4515 
     - estimate
4369 rajveer 4516 
     - isReminder
4303 rajveer 4517 
    """
4369 rajveer 4518 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4519 
    self.recv_markOrdersAsNotAvailabke()
4520 
 
4369 rajveer 4521 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4522 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4523 
    args = markOrdersAsNotAvailabke_args()
4524 
    args.vendorId = vendorId
4525 
    args.itemId = itemId
4526 
    args.quantity = quantity
4527 
    args.estimate = estimate
4369 rajveer 4528 
    args.isReminder = isReminder
4303 rajveer 4529 
    args.write(self._oprot)
4530 
    self._oprot.writeMessageEnd()
4531 
    self._oprot.trans.flush()
4532 
 
4533 
  def recv_markOrdersAsNotAvailabke(self, ):
4534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4535 
    if mtype == TMessageType.EXCEPTION:
4536 
      x = TApplicationException()
4537 
      x.read(self._iprot)
4538 
      self._iprot.readMessageEnd()
4539 
      raise x
4540 
    result = markOrdersAsNotAvailabke_result()
4541 
    result.read(self._iprot)
4542 
    self._iprot.readMessageEnd()
4543 
    if result.ex is not None:
4544 
      raise result.ex
4545 
    return
4546 
 
4369 rajveer 4547 
  def markOrdersAsTimeout(self, vendorId):
4548 
    """
4549 
    Parameters:
4550 
     - vendorId
4551 
    """
4552 
    self.send_markOrdersAsTimeout(vendorId)
4553 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4554 
 
4369 rajveer 4555 
  def send_markOrdersAsTimeout(self, vendorId):
4556 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4557 
    args = markOrdersAsTimeout_args()
4558 
    args.vendorId = vendorId
4559 
    args.write(self._oprot)
4560 
    self._oprot.writeMessageEnd()
4561 
    self._oprot.trans.flush()
4562 
 
4563 
  def recv_markOrdersAsTimeout(self, ):
4564 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4565 
    if mtype == TMessageType.EXCEPTION:
4566 
      x = TApplicationException()
4567 
      x.read(self._iprot)
4568 
      self._iprot.readMessageEnd()
4569 
      raise x
4570 
    result = markOrdersAsTimeout_result()
4571 
    result.read(self._iprot)
4572 
    self._iprot.readMessageEnd()
4573 
    if result.success is not None:
4574 
      return result.success
4575 
    if result.ex is not None:
4576 
      raise result.ex
4577 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4578 
 
4662 rajveer 4579 
  def markOrderAsLostInTransit(self, orderId):
4580 
    """
4581 
    Mark order as LOST_IN_TRANSIT
4582 
 
4583 
    Parameters:
4584 
     - orderId
4585 
    """
4586 
    self.send_markOrderAsLostInTransit(orderId)
4587 
    return self.recv_markOrderAsLostInTransit()
4588 
 
4589 
  def send_markOrderAsLostInTransit(self, orderId):
4590 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4591 
    args = markOrderAsLostInTransit_args()
4592 
    args.orderId = orderId
4593 
    args.write(self._oprot)
4594 
    self._oprot.writeMessageEnd()
4595 
    self._oprot.trans.flush()
4596 
 
4597 
  def recv_markOrderAsLostInTransit(self, ):
4598 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4599 
    if mtype == TMessageType.EXCEPTION:
4600 
      x = TApplicationException()
4601 
      x.read(self._iprot)
4602 
      self._iprot.readMessageEnd()
4603 
      raise x
4604 
    result = markOrderAsLostInTransit_result()
4605 
    result.read(self._iprot)
4606 
    self._iprot.readMessageEnd()
4607 
    if result.success is not None:
4608 
      return result.success
4609 
    if result.ex is not None:
4610 
      raise result.ex
4611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4612 
 
4386 anupam.sin 4613 
  def getOrderForAwb(self, awb):
4614 
    """
4615 
    Returns the order corresponding to an AWB number
4369 rajveer 4616 
 
4386 anupam.sin 4617 
    Parameters:
4618 
     - awb
4619 
    """
4620 
    self.send_getOrderForAwb(awb)
4621 
    return self.recv_getOrderForAwb()
4622 
 
4623 
  def send_getOrderForAwb(self, awb):
4624 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4625 
    args = getOrderForAwb_args()
4626 
    args.awb = awb
4627 
    args.write(self._oprot)
4628 
    self._oprot.writeMessageEnd()
4629 
    self._oprot.trans.flush()
4630 
 
4631 
  def recv_getOrderForAwb(self, ):
4632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4633 
    if mtype == TMessageType.EXCEPTION:
4634 
      x = TApplicationException()
4635 
      x.read(self._iprot)
4636 
      self._iprot.readMessageEnd()
4637 
      raise x
4638 
    result = getOrderForAwb_result()
4639 
    result.read(self._iprot)
4640 
    self._iprot.readMessageEnd()
4641 
    if result.success is not None:
4642 
      return result.success
4643 
    if result.ex is not None:
4644 
      raise result.ex
4645 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4646 
 
4910 phani.kuma 4647 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4648 
    """
4910 phani.kuma 4649 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4650 
 
4506 phani.kuma 4651 
    Parameters:
4652 
     - logistics_provider_id
4910 phani.kuma 4653 
     - order_status_list
4506 phani.kuma 4654 
    """
4910 phani.kuma 4655 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4656 
    return self.recv_getOrdersForProviderForStatus()
4657 
 
4910 phani.kuma 4658 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4659 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4660 
    args = getOrdersForProviderForStatus_args()
4661 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4662 
    args.order_status_list = order_status_list
4506 phani.kuma 4663 
    args.write(self._oprot)
4664 
    self._oprot.writeMessageEnd()
4665 
    self._oprot.trans.flush()
4666 
 
4667 
  def recv_getOrdersForProviderForStatus(self, ):
4668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4669 
    if mtype == TMessageType.EXCEPTION:
4670 
      x = TApplicationException()
4671 
      x.read(self._iprot)
4672 
      self._iprot.readMessageEnd()
4673 
      raise x
4674 
    result = getOrdersForProviderForStatus_result()
4675 
    result.read(self._iprot)
4676 
    self._iprot.readMessageEnd()
4677 
    if result.success is not None:
4678 
      return result.success
4679 
    if result.ex is not None:
4680 
      raise result.ex
4681 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4682 
 
4600 varun.gupt 4683 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4684 
    """
4685 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4686 
 
4600 varun.gupt 4687 
    Parameters:
4688 
     - vendorId
4689 
     - billingDateFrom
4690 
     - billingDateTo
4691 
    """
4692 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4693 
    return self.recv_getBilledOrdersForVendor()
4694 
 
4695 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4696 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4697 
    args = getBilledOrdersForVendor_args()
4698 
    args.vendorId = vendorId
4699 
    args.billingDateFrom = billingDateFrom
4700 
    args.billingDateTo = billingDateTo
4701 
    args.write(self._oprot)
4702 
    self._oprot.writeMessageEnd()
4703 
    self._oprot.trans.flush()
4704 
 
4705 
  def recv_getBilledOrdersForVendor(self, ):
4706 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4707 
    if mtype == TMessageType.EXCEPTION:
4708 
      x = TApplicationException()
4709 
      x.read(self._iprot)
4710 
      self._iprot.readMessageEnd()
4711 
      raise x
4712 
    result = getBilledOrdersForVendor_result()
4713 
    result.read(self._iprot)
4714 
    self._iprot.readMessageEnd()
4715 
    if result.success is not None:
4716 
      return result.success
4717 
    if result.ex is not None:
4718 
      raise result.ex
4719 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4720 
 
4607 rajveer 4721 
  def getSlippedSippingDateOrders(self, ):
4722 
    self.send_getSlippedSippingDateOrders()
4723 
    return self.recv_getSlippedSippingDateOrders()
4724 
 
4725 
  def send_getSlippedSippingDateOrders(self, ):
4726 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4727 
    args = getSlippedSippingDateOrders_args()
4728 
    args.write(self._oprot)
4729 
    self._oprot.writeMessageEnd()
4730 
    self._oprot.trans.flush()
4731 
 
4732 
  def recv_getSlippedSippingDateOrders(self, ):
4733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4734 
    if mtype == TMessageType.EXCEPTION:
4735 
      x = TApplicationException()
4736 
      x.read(self._iprot)
4737 
      self._iprot.readMessageEnd()
4738 
      raise x
4739 
    result = getSlippedSippingDateOrders_result()
4740 
    result.read(self._iprot)
4741 
    self._iprot.readMessageEnd()
4742 
    if result.success is not None:
4743 
      return result.success
4744 
    if result.ex is not None:
4745 
      raise result.ex
4746 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4747 
 
4709 rajveer 4748 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4749 
    """
4750 
    Parameters:
4751 
     - cancelDateFrom
4752 
     - cancelDateTo
4753 
    """
4754 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4755 
    return self.recv_getCancelledOrders()
4756 
 
4757 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4758 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4759 
    args = getCancelledOrders_args()
4760 
    args.cancelDateFrom = cancelDateFrom
4761 
    args.cancelDateTo = cancelDateTo
4762 
    args.write(self._oprot)
4763 
    self._oprot.writeMessageEnd()
4764 
    self._oprot.trans.flush()
4765 
 
4766 
  def recv_getCancelledOrders(self, ):
4767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4768 
    if mtype == TMessageType.EXCEPTION:
4769 
      x = TApplicationException()
4770 
      x.read(self._iprot)
4771 
      self._iprot.readMessageEnd()
4772 
      raise x
4773 
    result = getCancelledOrders_result()
4774 
    result.read(self._iprot)
4775 
    self._iprot.readMessageEnd()
4776 
    if result.success is not None:
4777 
      return result.success
4778 
    if result.ex is not None:
4779 
      raise result.ex
4780 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4781 
 
4600 varun.gupt 4782 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4783 
    """
4784 
    Parameters:
4785 
     - mapAWBAndAmount
4786 
    """
4787 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4788 
    self.recv_saveBluedartSettlements()
4789 
 
4790 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4791 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4792 
    args = saveBluedartSettlements_args()
4793 
    args.mapAWBAndAmount = mapAWBAndAmount
4794 
    args.write(self._oprot)
4795 
    self._oprot.writeMessageEnd()
4796 
    self._oprot.trans.flush()
4797 
 
4798 
  def recv_saveBluedartSettlements(self, ):
4799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4800 
    if mtype == TMessageType.EXCEPTION:
4801 
      x = TApplicationException()
4802 
      x.read(self._iprot)
4803 
      self._iprot.readMessageEnd()
4804 
      raise x
4805 
    result = saveBluedartSettlements_result()
4806 
    result.read(self._iprot)
4807 
    self._iprot.readMessageEnd()
4808 
    if result.ex is not None:
4809 
      raise result.ex
4810 
    return
4811 
 
4905 varun.gupt 4812 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4813 
    """
4814 
    Parameters:
4815 
     - settlementDate
4816 
     - paymentGatewayId
4905 varun.gupt 4817 
     - referenceId
4600 varun.gupt 4818 
     - serviceTax
4819 
     - otherCharges
4820 
     - netCollection
4821 
    """
4905 varun.gupt 4822 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4823 
    self.recv_savePaymentSettlements()
4824 
 
4905 varun.gupt 4825 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4826 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4827 
    args = savePaymentSettlements_args()
4828 
    args.settlementDate = settlementDate
4829 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4830 
    args.referenceId = referenceId
4600 varun.gupt 4831 
    args.serviceTax = serviceTax
4832 
    args.otherCharges = otherCharges
4833 
    args.netCollection = netCollection
4834 
    args.write(self._oprot)
4835 
    self._oprot.writeMessageEnd()
4836 
    self._oprot.trans.flush()
4837 
 
4838 
  def recv_savePaymentSettlements(self, ):
4839 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4840 
    if mtype == TMessageType.EXCEPTION:
4841 
      x = TApplicationException()
4842 
      x.read(self._iprot)
4843 
      self._iprot.readMessageEnd()
4844 
      raise x
4845 
    result = savePaymentSettlements_result()
4846 
    result.read(self._iprot)
4847 
    self._iprot.readMessageEnd()
4848 
    if result.ex is not None:
4849 
      raise result.ex
4850 
    return
4851 
 
4852 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4853 
    """
4854 
    Parameters:
4855 
     - settlementId
4856 
     - settlementDate
4857 
     - transactionDateFrom
4858 
     - transactionDateTo
4859 
     - amount
4860 
    """
4861 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4862 
    self.recv_saveEBSSettlementSummary()
4863 
 
4864 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4865 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4866 
    args = saveEBSSettlementSummary_args()
4867 
    args.settlementId = settlementId
4868 
    args.settlementDate = settlementDate
4869 
    args.transactionDateFrom = transactionDateFrom
4870 
    args.transactionDateTo = transactionDateTo
4871 
    args.amount = amount
4872 
    args.write(self._oprot)
4873 
    self._oprot.writeMessageEnd()
4874 
    self._oprot.trans.flush()
4875 
 
4876 
  def recv_saveEBSSettlementSummary(self, ):
4877 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4878 
    if mtype == TMessageType.EXCEPTION:
4879 
      x = TApplicationException()
4880 
      x.read(self._iprot)
4881 
      self._iprot.readMessageEnd()
4882 
      raise x
4883 
    result = saveEBSSettlementSummary_result()
4884 
    result.read(self._iprot)
4885 
    self._iprot.readMessageEnd()
4886 
    if result.ex is not None:
4887 
      raise result.ex
4888 
    return
4889 
 
5386 phani.kuma 4890 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 4891 
    """
4892 
    Parameters:
5189 varun.gupt 4893 
     - referenceId
4894 
     - isRefund
4600 varun.gupt 4895 
    """
5386 phani.kuma 4896 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
4897 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 4898 
 
5386 phani.kuma 4899 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
4900 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
4901 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 4902 
    args.referenceId = referenceId
4903 
    args.isRefund = isRefund
4600 varun.gupt 4904 
    args.write(self._oprot)
4905 
    self._oprot.writeMessageEnd()
4906 
    self._oprot.trans.flush()
4907 
 
5386 phani.kuma 4908 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 4909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4910 
    if mtype == TMessageType.EXCEPTION:
4911 
      x = TApplicationException()
4912 
      x.read(self._iprot)
4913 
      self._iprot.readMessageEnd()
4914 
      raise x
5386 phani.kuma 4915 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 4916 
    result.read(self._iprot)
4917 
    self._iprot.readMessageEnd()
4918 
    if result.success is not None:
4919 
      return result.success
4920 
    if result.ex is not None:
4921 
      raise result.ex
5386 phani.kuma 4922 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 4923 
 
5386 phani.kuma 4924 
  def getSettlementForCod(self, orderId, isRefund):
4925 
    """
4926 
    Parameters:
4927 
     - orderId
4928 
     - isRefund
4929 
    """
4930 
    self.send_getSettlementForCod(orderId, isRefund)
4931 
    return self.recv_getSettlementForCod()
4932 
 
4933 
  def send_getSettlementForCod(self, orderId, isRefund):
4934 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
4935 
    args = getSettlementForCod_args()
4936 
    args.orderId = orderId
4937 
    args.isRefund = isRefund
4938 
    args.write(self._oprot)
4939 
    self._oprot.writeMessageEnd()
4940 
    self._oprot.trans.flush()
4941 
 
4942 
  def recv_getSettlementForCod(self, ):
4943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4944 
    if mtype == TMessageType.EXCEPTION:
4945 
      x = TApplicationException()
4946 
      x.read(self._iprot)
4947 
      self._iprot.readMessageEnd()
4948 
      raise x
4949 
    result = getSettlementForCod_result()
4950 
    result.read(self._iprot)
4951 
    self._iprot.readMessageEnd()
4952 
    if result.success is not None:
4953 
      return result.success
4954 
    if result.ex is not None:
4955 
      raise result.ex
4956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
4957 
 
4600 varun.gupt 4958 
  def getEBSSettlementSummaries(self, ):
4959 
    self.send_getEBSSettlementSummaries()
4960 
    return self.recv_getEBSSettlementSummaries()
4961 
 
4962 
  def send_getEBSSettlementSummaries(self, ):
4963 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
4964 
    args = getEBSSettlementSummaries_args()
4965 
    args.write(self._oprot)
4966 
    self._oprot.writeMessageEnd()
4967 
    self._oprot.trans.flush()
4968 
 
4969 
  def recv_getEBSSettlementSummaries(self, ):
4970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4971 
    if mtype == TMessageType.EXCEPTION:
4972 
      x = TApplicationException()
4973 
      x.read(self._iprot)
4974 
      self._iprot.readMessageEnd()
4975 
      raise x
4976 
    result = getEBSSettlementSummaries_result()
4977 
    result.read(self._iprot)
4978 
    self._iprot.readMessageEnd()
4979 
    if result.success is not None:
4980 
      return result.success
4981 
    if result.ex is not None:
4982 
      raise result.ex
4983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
4984 
 
4985 
  def markEBSSettlementUploaded(self, settlementId):
4986 
    """
4987 
    Parameters:
4988 
     - settlementId
4989 
    """
4990 
    self.send_markEBSSettlementUploaded(settlementId)
4991 
    self.recv_markEBSSettlementUploaded()
4992 
 
4993 
  def send_markEBSSettlementUploaded(self, settlementId):
4994 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
4995 
    args = markEBSSettlementUploaded_args()
4996 
    args.settlementId = settlementId
4997 
    args.write(self._oprot)
4998 
    self._oprot.writeMessageEnd()
4999 
    self._oprot.trans.flush()
5000 
 
5001 
  def recv_markEBSSettlementUploaded(self, ):
5002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5003 
    if mtype == TMessageType.EXCEPTION:
5004 
      x = TApplicationException()
5005 
      x.read(self._iprot)
5006 
      self._iprot.readMessageEnd()
5007 
      raise x
5008 
    result = markEBSSettlementUploaded_result()
5009 
    result.read(self._iprot)
5010 
    self._iprot.readMessageEnd()
5011 
    if result.ex is not None:
5012 
      raise result.ex
5013 
    return
5014 
 
5015 
  def getEBSSettlementDate(self, settlementId):
5016 
    """
5017 
    Parameters:
5018 
     - settlementId
5019 
    """
5020 
    self.send_getEBSSettlementDate(settlementId)
5021 
    return self.recv_getEBSSettlementDate()
5022 
 
5023 
  def send_getEBSSettlementDate(self, settlementId):
5024 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5025 
    args = getEBSSettlementDate_args()
5026 
    args.settlementId = settlementId
5027 
    args.write(self._oprot)
5028 
    self._oprot.writeMessageEnd()
5029 
    self._oprot.trans.flush()
5030 
 
5031 
  def recv_getEBSSettlementDate(self, ):
5032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5033 
    if mtype == TMessageType.EXCEPTION:
5034 
      x = TApplicationException()
5035 
      x.read(self._iprot)
5036 
      self._iprot.readMessageEnd()
5037 
      raise x
5038 
    result = getEBSSettlementDate_result()
5039 
    result.read(self._iprot)
5040 
    self._iprot.readMessageEnd()
5041 
    if result.success is not None:
5042 
      return result.success
5043 
    if result.ex is not None:
5044 
      raise result.ex
5045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5046 
 
4715 varun.gupt 5047 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5048 
    """
5049 
    Parameters:
5050 
     - settlementDateFrom
5051 
     - settlementDateTo
5052 
     - isRefund
5053 
    """
5054 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5055 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5056 
 
4715 varun.gupt 5057 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5058 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5059 
    args = getSettlementsByDate_args()
5060 
    args.settlementDateFrom = settlementDateFrom
5061 
    args.settlementDateTo = settlementDateTo
5062 
    args.isRefund = isRefund
5063 
    args.write(self._oprot)
5064 
    self._oprot.writeMessageEnd()
5065 
    self._oprot.trans.flush()
5066 
 
5067 
  def recv_getSettlementsByDate(self, ):
5068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5069 
    if mtype == TMessageType.EXCEPTION:
5070 
      x = TApplicationException()
5071 
      x.read(self._iprot)
5072 
      self._iprot.readMessageEnd()
5073 
      raise x
5074 
    result = getSettlementsByDate_result()
5075 
    result.read(self._iprot)
5076 
    self._iprot.readMessageEnd()
5077 
    if result.success is not None:
5078 
      return result.success
5079 
    if result.ex is not None:
5080 
      raise result.ex
5081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5082 
 
5083 
  def getReshippedOrderIds(self, orderIds):
5084 
    """
5085 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5086 
 
5087 
    Parameters:
5088 
     - orderIds
5089 
    """
5090 
    self.send_getReshippedOrderIds(orderIds)
5091 
    return self.recv_getReshippedOrderIds()
5092 
 
5093 
  def send_getReshippedOrderIds(self, orderIds):
5094 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5095 
    args = getReshippedOrderIds_args()
5096 
    args.orderIds = orderIds
5097 
    args.write(self._oprot)
5098 
    self._oprot.writeMessageEnd()
5099 
    self._oprot.trans.flush()
5100 
 
5101 
  def recv_getReshippedOrderIds(self, ):
5102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5103 
    if mtype == TMessageType.EXCEPTION:
5104 
      x = TApplicationException()
5105 
      x.read(self._iprot)
5106 
      self._iprot.readMessageEnd()
5107 
      raise x
5108 
    result = getReshippedOrderIds_result()
5109 
    result.read(self._iprot)
5110 
    self._iprot.readMessageEnd()
5111 
    if result.success is not None:
5112 
      return result.success
5113 
    if result.ex is not None:
5114 
      raise result.ex
5115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5116 
 
5481 phani.kuma 5117 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5118 
    """
5119 
    Parameters:
5120 
     - vendorId
5481 phani.kuma 5121 
     - onlyVendorNotPaid
5122 
     - billingDateFrom
5123 
     - billingDateTo
4875 varun.gupt 5124 
    """
5481 phani.kuma 5125 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5126 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5127 
 
5481 phani.kuma 5128 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5129 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5130 
    args = getBilledOrders_args()
4875 varun.gupt 5131 
    args.vendorId = vendorId
5481 phani.kuma 5132 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5133 
    args.billingDateFrom = billingDateFrom
5134 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5135 
    args.write(self._oprot)
5136 
    self._oprot.writeMessageEnd()
5137 
    self._oprot.trans.flush()
5138 
 
5481 phani.kuma 5139 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5141 
    if mtype == TMessageType.EXCEPTION:
5142 
      x = TApplicationException()
5143 
      x.read(self._iprot)
5144 
      self._iprot.readMessageEnd()
5145 
      raise x
5481 phani.kuma 5146 
    result = getBilledOrders_result()
4875 varun.gupt 5147 
    result.read(self._iprot)
5148 
    self._iprot.readMessageEnd()
5149 
    if result.success is not None:
5150 
      return result.success
5151 
    if result.ex is not None:
5152 
      raise result.ex
5481 phani.kuma 5153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5154 
 
5031 varun.gupt 5155 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5156 
    """
5157 
    Parameters:
5158 
     - startDate
5159 
     - endDate
5160 
    """
5161 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5162 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5163 
 
5031 varun.gupt 5164 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5165 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5166 
    args = getStatusDistributionOfOrders_args()
5167 
    args.startDate = startDate
5168 
    args.endDate = endDate
5169 
    args.write(self._oprot)
5170 
    self._oprot.writeMessageEnd()
5171 
    self._oprot.trans.flush()
5172 
 
5173 
  def recv_getStatusDistributionOfOrders(self, ):
5174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5175 
    if mtype == TMessageType.EXCEPTION:
5176 
      x = TApplicationException()
5177 
      x.read(self._iprot)
5178 
      self._iprot.readMessageEnd()
5179 
      raise x
5180 
    result = getStatusDistributionOfOrders_result()
5181 
    result.read(self._iprot)
5182 
    self._iprot.readMessageEnd()
5183 
    if result.success is not None:
5184 
      return result.success
5185 
    if result.ex is not None:
5186 
      raise result.ex
5187 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5188 
 
5067 varun.gupt 5189 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5190 
    """
5191 
    Parameters:
5192 
     - status
5193 
     - startDatetime
5194 
     - endDatetime
5195 
    """
5196 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5197 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5198 
 
5067 varun.gupt 5199 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5200 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5201 
    args = getOrderIdsForStatus_args()
5202 
    args.status = status
5203 
    args.startDatetime = startDatetime
5204 
    args.endDatetime = endDatetime
5205 
    args.write(self._oprot)
5206 
    self._oprot.writeMessageEnd()
5207 
    self._oprot.trans.flush()
5208 
 
5209 
  def recv_getOrderIdsForStatus(self, ):
5210 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5211 
    if mtype == TMessageType.EXCEPTION:
5212 
      x = TApplicationException()
5213 
      x.read(self._iprot)
5214 
      self._iprot.readMessageEnd()
5215 
      raise x
5216 
    result = getOrderIdsForStatus_result()
5217 
    result.read(self._iprot)
5218 
    self._iprot.readMessageEnd()
5219 
    if result.success is not None:
5220 
      return result.success
5221 
    if result.ex is not None:
5222 
      raise result.ex
5223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5224 
 
5348 anupam.sin 5225 
  def updateCODAgent(self, agent, orderId):
5226 
    """
5227 
    Updates the agent who handled the COD verification call
5228 
 
5229 
    Parameters:
5230 
     - agent
5231 
     - orderId
5232 
    """
5233 
    self.send_updateCODAgent(agent, orderId)
5234 
    self.recv_updateCODAgent()
5235 
 
5236 
  def send_updateCODAgent(self, agent, orderId):
5237 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5238 
    args = updateCODAgent_args()
5239 
    args.agent = agent
5240 
    args.orderId = orderId
5241 
    args.write(self._oprot)
5242 
    self._oprot.writeMessageEnd()
5243 
    self._oprot.trans.flush()
5244 
 
5245 
  def recv_updateCODAgent(self, ):
5246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5247 
    if mtype == TMessageType.EXCEPTION:
5248 
      x = TApplicationException()
5249 
      x.read(self._iprot)
5250 
      self._iprot.readMessageEnd()
5251 
      raise x
5252 
    result = updateCODAgent_result()
5253 
    result.read(self._iprot)
5254 
    self._iprot.readMessageEnd()
5255 
    if result.ex is not None:
5256 
      raise result.ex
5257 
    return
5258 
 
5099 varun.gupt 5259 
  def updateOrderAsPaidToVendor(self, orderId):
5260 
    """
5261 
    Parameters:
5262 
     - orderId
5263 
    """
5264 
    self.send_updateOrderAsPaidToVendor(orderId)
5265 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5266 
 
5099 varun.gupt 5267 
  def send_updateOrderAsPaidToVendor(self, orderId):
5268 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5269 
    args = updateOrderAsPaidToVendor_args()
5270 
    args.orderId = orderId
5271 
    args.write(self._oprot)
5272 
    self._oprot.writeMessageEnd()
5273 
    self._oprot.trans.flush()
5274 
 
5275 
  def recv_updateOrderAsPaidToVendor(self, ):
5276 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5277 
    if mtype == TMessageType.EXCEPTION:
5278 
      x = TApplicationException()
5279 
      x.read(self._iprot)
5280 
      self._iprot.readMessageEnd()
5281 
      raise x
5282 
    result = updateOrderAsPaidToVendor_result()
5283 
    result.read(self._iprot)
5284 
    self._iprot.readMessageEnd()
5285 
    if result.ex is not None:
5286 
      raise result.ex
5287 
    return
5288 
 
5386 phani.kuma 5289 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5290 
    """
5291 
    Parameters:
5292 
     - orderId
5293 
    """
5294 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5295 
    self.recv_updateOrderOnlyAsPaidToVendor()
5296 
 
5297 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5298 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5299 
    args = updateOrderOnlyAsPaidToVendor_args()
5300 
    args.orderId = orderId
5301 
    args.write(self._oprot)
5302 
    self._oprot.writeMessageEnd()
5303 
    self._oprot.trans.flush()
5304 
 
5305 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5306 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5307 
    if mtype == TMessageType.EXCEPTION:
5308 
      x = TApplicationException()
5309 
      x.read(self._iprot)
5310 
      self._iprot.readMessageEnd()
5311 
      raise x
5312 
    result = updateOrderOnlyAsPaidToVendor_result()
5313 
    result.read(self._iprot)
5314 
    self._iprot.readMessageEnd()
5315 
    if result.ex is not None:
5316 
      raise result.ex
5317 
    return
5318 
 
5208 varun.gupt 5319 
  def getRefundedOrdersMarkedPaid(self, ):
5320 
    self.send_getRefundedOrdersMarkedPaid()
5321 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5322 
 
5208 varun.gupt 5323 
  def send_getRefundedOrdersMarkedPaid(self, ):
5324 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5325 
    args = getRefundedOrdersMarkedPaid_args()
5326 
    args.write(self._oprot)
5327 
    self._oprot.writeMessageEnd()
5328 
    self._oprot.trans.flush()
5329 
 
5330 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5332 
    if mtype == TMessageType.EXCEPTION:
5333 
      x = TApplicationException()
5334 
      x.read(self._iprot)
5335 
      self._iprot.readMessageEnd()
5336 
      raise x
5337 
    result = getRefundedOrdersMarkedPaid_result()
5338 
    result.read(self._iprot)
5339 
    self._iprot.readMessageEnd()
5340 
    if result.success is not None:
5341 
      return result.success
5342 
    if result.ex is not None:
5343 
      raise result.ex
5344 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5345 
 
5447 anupam.sin 5346 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5347 
    """
5348 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5349 
 
5447 anupam.sin 5350 
 
5351 
    Parameters:
5352 
     - minOrderId
5353 
     - maxOrderId
5354 
    """
5355 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5356 
    return self.recv_getAllVerificationAgents()
5357 
 
5358 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5359 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5360 
    args = getAllVerificationAgents_args()
5361 
    args.minOrderId = minOrderId
5362 
    args.maxOrderId = maxOrderId
5363 
    args.write(self._oprot)
5364 
    self._oprot.writeMessageEnd()
5365 
    self._oprot.trans.flush()
5366 
 
5367 
  def recv_getAllVerificationAgents(self, ):
5368 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5369 
    if mtype == TMessageType.EXCEPTION:
5370 
      x = TApplicationException()
5371 
      x.read(self._iprot)
5372 
      self._iprot.readMessageEnd()
5373 
      raise x
5374 
    result = getAllVerificationAgents_result()
5375 
    result.read(self._iprot)
5376 
    self._iprot.readMessageEnd()
5377 
    if result.success is not None:
5378 
      return result.success
5379 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5380 
 
5527 anupam.sin 5381 
  def getAllAttributesForOrderId(self, orderId):
5382 
    """
5383 
    gets all attributes for a given orderId
5447 anupam.sin 5384 
 
5527 anupam.sin 5385 
    Parameters:
5386 
     - orderId
5387 
    """
5388 
    self.send_getAllAttributesForOrderId(orderId)
5389 
    return self.recv_getAllAttributesForOrderId()
5390 
 
5391 
  def send_getAllAttributesForOrderId(self, orderId):
5392 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5393 
    args = getAllAttributesForOrderId_args()
5394 
    args.orderId = orderId
5395 
    args.write(self._oprot)
5396 
    self._oprot.writeMessageEnd()
5397 
    self._oprot.trans.flush()
5398 
 
5399 
  def recv_getAllAttributesForOrderId(self, ):
5400 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5401 
    if mtype == TMessageType.EXCEPTION:
5402 
      x = TApplicationException()
5403 
      x.read(self._iprot)
5404 
      self._iprot.readMessageEnd()
5405 
      raise x
5406 
    result = getAllAttributesForOrderId_result()
5407 
    result.read(self._iprot)
5408 
    self._iprot.readMessageEnd()
5409 
    if result.success is not None:
5410 
      return result.success
5411 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5412 
 
5676 rajveer 5413 
  def setOrderAttributes(self, orderId, attributes):
5414 
    """
5415 
    sets attributes for an order
5416 
 
5417 
    Parameters:
5418 
     - orderId
5419 
     - attributes
5420 
    """
5421 
    self.send_setOrderAttributes(orderId, attributes)
5422 
    self.recv_setOrderAttributes()
5423 
 
5424 
  def send_setOrderAttributes(self, orderId, attributes):
5425 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5426 
    args = setOrderAttributes_args()
5427 
    args.orderId = orderId
5428 
    args.attributes = attributes
5429 
    args.write(self._oprot)
5430 
    self._oprot.writeMessageEnd()
5431 
    self._oprot.trans.flush()
5432 
 
5433 
  def recv_setOrderAttributes(self, ):
5434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5435 
    if mtype == TMessageType.EXCEPTION:
5436 
      x = TApplicationException()
5437 
      x.read(self._iprot)
5438 
      self._iprot.readMessageEnd()
5439 
      raise x
5440 
    result = setOrderAttributes_result()
5441 
    result.read(self._iprot)
5442 
    self._iprot.readMessageEnd()
5443 
    return
5444 
 
5527 anupam.sin 5445 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5446 
    """
5447 
    sets attributes for all orders in a transaction
5448 
 
5449 
    Parameters:
5450 
     - transactionId
5451 
     - attribute
5452 
    """
5453 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5454 
    self.recv_setOrderAttributeForTransaction()
5455 
 
5456 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5457 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5458 
    args = setOrderAttributeForTransaction_args()
5459 
    args.transactionId = transactionId
5460 
    args.attribute = attribute
5461 
    args.write(self._oprot)
5462 
    self._oprot.writeMessageEnd()
5463 
    self._oprot.trans.flush()
5464 
 
5465 
  def recv_setOrderAttributeForTransaction(self, ):
5466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5467 
    if mtype == TMessageType.EXCEPTION:
5468 
      x = TApplicationException()
5469 
      x.read(self._iprot)
5470 
      self._iprot.readMessageEnd()
5471 
      raise x
5472 
    result = setOrderAttributeForTransaction_result()
5473 
    result.read(self._iprot)
5474 
    self._iprot.readMessageEnd()
5475 
    return
5476 
 
5553 rajveer 5477 
  def getReceivePendingOrders(self, storeId):
5478 
    """
5479 
    Parameters:
5480 
     - storeId
5481 
    """
5482 
    self.send_getReceivePendingOrders(storeId)
5483 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5484 
 
5553 rajveer 5485 
  def send_getReceivePendingOrders(self, storeId):
5486 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5487 
    args = getReceivePendingOrders_args()
5488 
    args.storeId = storeId
5489 
    args.write(self._oprot)
5490 
    self._oprot.writeMessageEnd()
5491 
    self._oprot.trans.flush()
5492 
 
5493 
  def recv_getReceivePendingOrders(self, ):
5494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5495 
    if mtype == TMessageType.EXCEPTION:
5496 
      x = TApplicationException()
5497 
      x.read(self._iprot)
5498 
      self._iprot.readMessageEnd()
5499 
      raise x
5500 
    result = getReceivePendingOrders_result()
5501 
    result.read(self._iprot)
5502 
    self._iprot.readMessageEnd()
5503 
    if result.success is not None:
5504 
      return result.success
5505 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5506 
 
5507 
  def getReceivedAtStoreOrders(self, storeId):
5508 
    """
5509 
    Parameters:
5510 
     - storeId
5511 
    """
5512 
    self.send_getReceivedAtStoreOrders(storeId)
5513 
    return self.recv_getReceivedAtStoreOrders()
5514 
 
5515 
  def send_getReceivedAtStoreOrders(self, storeId):
5516 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5517 
    args = getReceivedAtStoreOrders_args()
5518 
    args.storeId = storeId
5519 
    args.write(self._oprot)
5520 
    self._oprot.writeMessageEnd()
5521 
    self._oprot.trans.flush()
5522 
 
5523 
  def recv_getReceivedAtStoreOrders(self, ):
5524 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5525 
    if mtype == TMessageType.EXCEPTION:
5526 
      x = TApplicationException()
5527 
      x.read(self._iprot)
5528 
      self._iprot.readMessageEnd()
5529 
      raise x
5530 
    result = getReceivedAtStoreOrders_result()
5531 
    result.read(self._iprot)
5532 
    self._iprot.readMessageEnd()
5533 
    if result.success is not None:
5534 
      return result.success
5535 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5536 
 
5713 rajveer 5537 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5538 
    """
5539 
    Parameters:
5540 
     - storeId
5541 
     - fromDate
5542 
     - toDate
5543 
     - onlyCod
5544 
    """
5545 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5546 
    return self.recv_getOrdersCollectionAtStore()
5547 
 
5548 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5549 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5550 
    args = getOrdersCollectionAtStore_args()
5551 
    args.storeId = storeId
5552 
    args.fromDate = fromDate
5553 
    args.toDate = toDate
5554 
    args.onlyCod = onlyCod
5555 
    args.write(self._oprot)
5556 
    self._oprot.writeMessageEnd()
5557 
    self._oprot.trans.flush()
5558 
 
5559 
  def recv_getOrdersCollectionAtStore(self, ):
5560 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5561 
    if mtype == TMessageType.EXCEPTION:
5562 
      x = TApplicationException()
5563 
      x.read(self._iprot)
5564 
      self._iprot.readMessageEnd()
5565 
      raise x
5566 
    result = getOrdersCollectionAtStore_result()
5567 
    result.read(self._iprot)
5568 
    self._iprot.readMessageEnd()
5569 
    if result.success is not None:
5570 
      return result.success
5571 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5572 
 
5593 mandeep.dh 5573 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5574 
    """
5575 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5576 
    invoked while scanning IN of items.
5553 rajveer 5577 
 
5593 mandeep.dh 5578 
    Parameters:
5579 
     - itemId
5580 
     - quantity
5581 
     - fulfilmentWarehouseId
5582 
     - billingWarehouseId
5583 
    """
5584 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5585 
    self.recv_acceptOrderForItem()
5586 
 
5587 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5588 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5589 
    args = acceptOrderForItem_args()
5590 
    args.itemId = itemId
5591 
    args.quantity = quantity
5592 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5593 
    args.billingWarehouseId = billingWarehouseId
5594 
    args.write(self._oprot)
5595 
    self._oprot.writeMessageEnd()
5596 
    self._oprot.trans.flush()
5597 
 
5598 
  def recv_acceptOrderForItem(self, ):
5599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5600 
    if mtype == TMessageType.EXCEPTION:
5601 
      x = TApplicationException()
5602 
      x.read(self._iprot)
5603 
      self._iprot.readMessageEnd()
5604 
      raise x
5605 
    result = acceptOrderForItem_result()
5606 
    result.read(self._iprot)
5607 
    self._iprot.readMessageEnd()
5608 
    return
5609 
 
5610 
 
3376 rajveer 5611 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 5612 
  def __init__(self, handler):
3376 rajveer 5613 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 5614 
    self._processMap["createTransaction"] = Processor.process_createTransaction
5615 
    self._processMap["getTransaction"] = Processor.process_getTransaction
5616 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 5617 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 5618 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
5619 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 5620 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 5621 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 5622 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
5623 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 5624 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 5625 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 5626 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
5627 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 5628 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
5629 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
5630 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
5631 
    self._processMap["createOrder"] = Processor.process_createOrder
5632 
    self._processMap["getOrder"] = Processor.process_getOrder
5633 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 5634 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 5635 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 5636 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 5637 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 5638 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 5639 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 5640 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
5641 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
5642 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
5643 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 5644 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 5645 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 5646 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
5647 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
5648 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 5649 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 5650 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 5651 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 5652 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 5653 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 5654 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 5655 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
5656 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 5657 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 5658 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
5659 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
5660 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
5661 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
5662 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 5663 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 5664 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 5665 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 5666 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 5667 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 5668 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
5669 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 5670 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
5671 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 5672 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
5673 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 5674 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 5675 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 5676 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 5677 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 5678 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 5679 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 5680 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 5681 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
5682 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 5683 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 5684 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 5685 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 5686 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 5687 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 5688 
    self._processMap["changeItem"] = Processor.process_changeItem
5689 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 5690 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 5691 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 5692 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
5693 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 5694 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 5695 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 5696 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
5697 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
5698 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 5699 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 5700 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 5701 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 5702 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 5703 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
5704 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
5705 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 5706 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 5707 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 5708 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 5709 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 5710 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 5711 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 5712 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 5713 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
5714 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
5715 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 5716 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
5717 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 5718 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
5719 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
5720 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 5721 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
5722 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 5723 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 5724 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 5725 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 5726 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 5727 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 5728 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 5729 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 5730 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 5731 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 5732 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 5733 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 5734 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
5735 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 5736 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5593 mandeep.dh 5737 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
94 ashish 5738 
 
5739 
  def process(self, iprot, oprot):
5740 
    (name, type, seqid) = iprot.readMessageBegin()
5741 
    if name not in self._processMap:
5742 
      iprot.skip(TType.STRUCT)
5743 
      iprot.readMessageEnd()
5744 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
5745 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
5746 
      x.write(oprot)
5747 
      oprot.writeMessageEnd()
5748 
      oprot.trans.flush()
5749 
      return
5750 
    else:
5751 
      self._processMap[name](self, seqid, iprot, oprot)
5752 
    return True
5753 
 
5754 
  def process_createTransaction(self, seqid, iprot, oprot):
5755 
    args = createTransaction_args()
5756 
    args.read(iprot)
5757 
    iprot.readMessageEnd()
5758 
    result = createTransaction_result()
5759 
    try:
132 ashish 5760 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 5761 
    except TransactionServiceException, ex:
5762 
      result.ex = ex
5763 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
5764 
    result.write(oprot)
5765 
    oprot.writeMessageEnd()
5766 
    oprot.trans.flush()
5767 
 
5768 
  def process_getTransaction(self, seqid, iprot, oprot):
5769 
    args = getTransaction_args()
5770 
    args.read(iprot)
5771 
    iprot.readMessageEnd()
5772 
    result = getTransaction_result()
5773 
    try:
5774 
      result.success = self._handler.getTransaction(args.id)
5775 
    except TransactionServiceException, ex:
5776 
      result.ex = ex
5777 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
5778 
    result.write(oprot)
5779 
    oprot.writeMessageEnd()
5780 
    oprot.trans.flush()
5781 
 
5782 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
5783 
    args = getTransactionsForCustomer_args()
5784 
    args.read(iprot)
5785 
    iprot.readMessageEnd()
5786 
    result = getTransactionsForCustomer_result()
5787 
    try:
5788 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
5789 
    except TransactionServiceException, ex:
5790 
      result.ex = ex
5791 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
5792 
    result.write(oprot)
5793 
    oprot.writeMessageEnd()
5794 
    oprot.trans.flush()
5795 
 
132 ashish 5796 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
5797 
    args = getTransactionsForShoppingCartId_args()
5798 
    args.read(iprot)
5799 
    iprot.readMessageEnd()
5800 
    result = getTransactionsForShoppingCartId_result()
5801 
    try:
5802 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
5803 
    except TransactionServiceException, ex:
5804 
      result.ex = ex
5805 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
5806 
    result.write(oprot)
5807 
    oprot.writeMessageEnd()
5808 
    oprot.trans.flush()
5809 
 
94 ashish 5810 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
5811 
    args = getTransactionStatus_args()
5812 
    args.read(iprot)
5813 
    iprot.readMessageEnd()
5814 
    result = getTransactionStatus_result()
5815 
    try:
5816 
      result.success = self._handler.getTransactionStatus(args.transactionId)
5817 
    except TransactionServiceException, ex:
5818 
      result.ex = ex
5819 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
5820 
    result.write(oprot)
5821 
    oprot.writeMessageEnd()
5822 
    oprot.trans.flush()
5823 
 
5824 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
5825 
    args = changeTransactionStatus_args()
5826 
    args.read(iprot)
5827 
    iprot.readMessageEnd()
5828 
    result = changeTransactionStatus_result()
5829 
    try:
5527 anupam.sin 5830 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 5831 
    except TransactionServiceException, ex:
5832 
      result.ex = ex
5833 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
5834 
    result.write(oprot)
5835 
    oprot.writeMessageEnd()
5836 
    oprot.trans.flush()
5837 
 
1398 varun.gupt 5838 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
5839 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 5840 
    args.read(iprot)
5841 
    iprot.readMessageEnd()
1398 varun.gupt 5842 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 5843 
    try:
1398 varun.gupt 5844 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 5845 
    except TransactionServiceException, ex:
5846 
      result.ex = ex
1398 varun.gupt 5847 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 5848 
    result.write(oprot)
5849 
    oprot.writeMessageEnd()
5850 
    oprot.trans.flush()
5851 
 
483 rajveer 5852 
  def process_getAllOrders(self, seqid, iprot, oprot):
5853 
    args = getAllOrders_args()
94 ashish 5854 
    args.read(iprot)
5855 
    iprot.readMessageEnd()
483 rajveer 5856 
    result = getAllOrders_result()
94 ashish 5857 
    try:
4801 anupam.sin 5858 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 5859 
    except TransactionServiceException, ex:
5860 
      result.ex = ex
483 rajveer 5861 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 5862 
    result.write(oprot)
5863 
    oprot.writeMessageEnd()
5864 
    oprot.trans.flush()
5865 
 
4133 chandransh 5866 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
5867 
    args = getOrdersInBatch_args()
5868 
    args.read(iprot)
5869 
    iprot.readMessageEnd()
5870 
    result = getOrdersInBatch_result()
5871 
    try:
5872 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
5873 
    except TransactionServiceException, ex:
5874 
      result.ex = ex
5875 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
5876 
    result.write(oprot)
5877 
    oprot.writeMessageEnd()
5878 
    oprot.trans.flush()
5879 
 
5880 
  def process_getOrderCount(self, seqid, iprot, oprot):
5881 
    args = getOrderCount_args()
5882 
    args.read(iprot)
5883 
    iprot.readMessageEnd()
5884 
    result = getOrderCount_result()
5885 
    try:
5886 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
5887 
    except TransactionServiceException, ex:
5888 
      result.ex = ex
5889 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
5890 
    result.write(oprot)
5891 
    oprot.writeMessageEnd()
5892 
    oprot.trans.flush()
5893 
 
999 varun.gupt 5894 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
5895 
    args = getOrdersByBillingDate_args()
5896 
    args.read(iprot)
5897 
    iprot.readMessageEnd()
5898 
    result = getOrdersByBillingDate_result()
5899 
    try:
5900 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
5901 
    except TransactionServiceException, ex:
5902 
      result.ex = ex
5903 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
5904 
    result.write(oprot)
5905 
    oprot.writeMessageEnd()
5906 
    oprot.trans.flush()
5907 
 
3427 chandransh 5908 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
5909 
    args = getOrdersByShippingDate_args()
5910 
    args.read(iprot)
5911 
    iprot.readMessageEnd()
5912 
    result = getOrdersByShippingDate_result()
5913 
    try:
3451 chandransh 5914 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 5915 
    except TransactionServiceException, ex:
5916 
      result.ex = ex
5917 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
5918 
    result.write(oprot)
5919 
    oprot.writeMessageEnd()
5920 
    oprot.trans.flush()
5921 
 
1382 varun.gupt 5922 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
5923 
    args = getReturnableOrdersForCustomer_args()
5924 
    args.read(iprot)
5925 
    iprot.readMessageEnd()
5926 
    result = getReturnableOrdersForCustomer_result()
5927 
    try:
5928 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
5929 
    except TransactionServiceException, ex:
5930 
      result.ex = ex
5931 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
5932 
    result.write(oprot)
5933 
    oprot.writeMessageEnd()
5934 
    oprot.trans.flush()
5935 
 
5936 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
5937 
    args = getCancellableOrdersForCustomer_args()
5938 
    args.read(iprot)
5939 
    iprot.readMessageEnd()
5940 
    result = getCancellableOrdersForCustomer_result()
5941 
    try:
5942 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
5943 
    except TransactionServiceException, ex:
5944 
      result.ex = ex
5945 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
5946 
    result.write(oprot)
5947 
    oprot.writeMessageEnd()
5948 
    oprot.trans.flush()
5949 
 
483 rajveer 5950 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
5951 
    args = changeOrderStatus_args()
94 ashish 5952 
    args.read(iprot)
5953 
    iprot.readMessageEnd()
483 rajveer 5954 
    result = changeOrderStatus_result()
94 ashish 5955 
    try:
483 rajveer 5956 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 5957 
    except TransactionServiceException, ex:
5958 
      result.ex = ex
483 rajveer 5959 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 5960 
    result.write(oprot)
5961 
    oprot.writeMessageEnd()
5962 
    oprot.trans.flush()
5963 
 
483 rajveer 5964 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
5965 
    args = getOrdersForTransaction_args()
94 ashish 5966 
    args.read(iprot)
5967 
    iprot.readMessageEnd()
483 rajveer 5968 
    result = getOrdersForTransaction_result()
94 ashish 5969 
    try:
1528 ankur.sing 5970 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 5971 
    except TransactionServiceException, ex:
5972 
      result.ex = ex
483 rajveer 5973 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 5974 
    result.write(oprot)
5975 
    oprot.writeMessageEnd()
5976 
    oprot.trans.flush()
5977 
 
483 rajveer 5978 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
5979 
    args = getOrdersForCustomer_args()
94 ashish 5980 
    args.read(iprot)
5981 
    iprot.readMessageEnd()
483 rajveer 5982 
    result = getOrdersForCustomer_result()
94 ashish 5983 
    try:
3014 chandransh 5984 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 5985 
    except TransactionServiceException, ex:
5986 
      result.ex = ex
483 rajveer 5987 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 5988 
    result.write(oprot)
5989 
    oprot.writeMessageEnd()
5990 
    oprot.trans.flush()
5991 
 
483 rajveer 5992 
  def process_createOrder(self, seqid, iprot, oprot):
5993 
    args = createOrder_args()
94 ashish 5994 
    args.read(iprot)
5995 
    iprot.readMessageEnd()
483 rajveer 5996 
    result = createOrder_result()
94 ashish 5997 
    try:
483 rajveer 5998 
      result.success = self._handler.createOrder(args.order)
94 ashish 5999 
    except TransactionServiceException, ex:
6000 
      result.ex = ex
483 rajveer 6001 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6002 
    result.write(oprot)
6003 
    oprot.writeMessageEnd()
6004 
    oprot.trans.flush()
6005 
 
483 rajveer 6006 
  def process_getOrder(self, seqid, iprot, oprot):
6007 
    args = getOrder_args()
94 ashish 6008 
    args.read(iprot)
6009 
    iprot.readMessageEnd()
483 rajveer 6010 
    result = getOrder_result()
94 ashish 6011 
    try:
483 rajveer 6012 
      result.success = self._handler.getOrder(args.id)
94 ashish 6013 
    except TransactionServiceException, ex:
6014 
      result.ex = ex
483 rajveer 6015 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6016 
    result.write(oprot)
6017 
    oprot.writeMessageEnd()
6018 
    oprot.trans.flush()
6019 
 
483 rajveer 6020 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6021 
    args = getLineItemsForOrder_args()
94 ashish 6022 
    args.read(iprot)
6023 
    iprot.readMessageEnd()
483 rajveer 6024 
    result = getLineItemsForOrder_result()
94 ashish 6025 
    try:
483 rajveer 6026 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6027 
    except TransactionServiceException, ex:
6028 
      result.ex = ex
483 rajveer 6029 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6030 
    result.write(oprot)
6031 
    oprot.writeMessageEnd()
6032 
    oprot.trans.flush()
6033 
 
4999 phani.kuma 6034 
  def process_getOrderList(self, seqid, iprot, oprot):
6035 
    args = getOrderList_args()
6036 
    args.read(iprot)
6037 
    iprot.readMessageEnd()
6038 
    result = getOrderList_result()
6039 
    result.success = self._handler.getOrderList(args.order_ids)
6040 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6041 
    result.write(oprot)
6042 
    oprot.writeMessageEnd()
6043 
    oprot.trans.flush()
6044 
 
5386 phani.kuma 6045 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6046 
    args = getOrderListForVendor_args()
6047 
    args.read(iprot)
6048 
    iprot.readMessageEnd()
6049 
    result = getOrderListForVendor_result()
6050 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6051 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6052 
    result.write(oprot)
6053 
    oprot.writeMessageEnd()
6054 
    oprot.trans.flush()
6055 
 
1528 ankur.sing 6056 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6057 
    args = getOrderForCustomer_args()
6058 
    args.read(iprot)
6059 
    iprot.readMessageEnd()
6060 
    result = getOrderForCustomer_result()
6061 
    try:
6062 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6063 
    except TransactionServiceException, ex:
6064 
      result.ex = ex
6065 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6066 
    result.write(oprot)
6067 
    oprot.writeMessageEnd()
6068 
    oprot.trans.flush()
6069 
 
3064 chandransh 6070 
  def process_getAlerts(self, seqid, iprot, oprot):
6071 
    args = getAlerts_args()
6072 
    args.read(iprot)
6073 
    iprot.readMessageEnd()
6074 
    result = getAlerts_result()
4444 rajveer 6075 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6076 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6077 
    result.write(oprot)
6078 
    oprot.writeMessageEnd()
6079 
    oprot.trans.flush()
6080 
 
4394 rajveer 6081 
  def process_addAlert(self, seqid, iprot, oprot):
6082 
    args = addAlert_args()
3064 chandransh 6083 
    args.read(iprot)
6084 
    iprot.readMessageEnd()
4394 rajveer 6085 
    result = addAlert_result()
4444 rajveer 6086 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6087 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6088 
    result.write(oprot)
6089 
    oprot.writeMessageEnd()
6090 
    oprot.trans.flush()
6091 
 
4444 rajveer 6092 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6093 
    args = markAlertsAsSeen_args()
6094 
    args.read(iprot)
6095 
    iprot.readMessageEnd()
6096 
    result = markAlertsAsSeen_result()
6097 
    self._handler.markAlertsAsSeen(args.warehouseId)
6098 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6099 
    result.write(oprot)
6100 
    oprot.writeMessageEnd()
6101 
    oprot.trans.flush()
6102 
 
3064 chandransh 6103 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6104 
    args = getValidOrderCount_args()
6105 
    args.read(iprot)
6106 
    iprot.readMessageEnd()
6107 
    result = getValidOrderCount_result()
6108 
    result.success = self._handler.getValidOrderCount()
6109 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6110 
    result.write(oprot)
6111 
    oprot.writeMessageEnd()
6112 
    oprot.trans.flush()
6113 
 
6114 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6115 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6116 
    args.read(iprot)
6117 
    iprot.readMessageEnd()
6118 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6119 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6120 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6121 
    result.write(oprot)
6122 
    oprot.writeMessageEnd()
6123 
    oprot.trans.flush()
6124 
 
6125 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6126 
    args = getValidOrdersAmountRange_args()
6127 
    args.read(iprot)
6128 
    iprot.readMessageEnd()
6129 
    result = getValidOrdersAmountRange_result()
6130 
    result.success = self._handler.getValidOrdersAmountRange()
6131 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6132 
    result.write(oprot)
6133 
    oprot.writeMessageEnd()
6134 
    oprot.trans.flush()
6135 
 
6136 
  def process_getValidOrders(self, seqid, iprot, oprot):
6137 
    args = getValidOrders_args()
6138 
    args.read(iprot)
6139 
    iprot.readMessageEnd()
6140 
    result = getValidOrders_result()
6141 
    result.success = self._handler.getValidOrders(args.limit)
6142 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6143 
    result.write(oprot)
6144 
    oprot.writeMessageEnd()
6145 
    oprot.trans.flush()
6146 
 
1220 chandransh 6147 
  def process_batchOrders(self, seqid, iprot, oprot):
6148 
    args = batchOrders_args()
6149 
    args.read(iprot)
6150 
    iprot.readMessageEnd()
6151 
    result = batchOrders_result()
6152 
    try:
6153 
      result.success = self._handler.batchOrders(args.warehouseId)
6154 
    except TransactionServiceException, ex:
6155 
      result.ex = ex
6156 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6157 
    result.write(oprot)
6158 
    oprot.writeMessageEnd()
6159 
    oprot.trans.flush()
6160 
 
1208 chandransh 6161 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6162 
    args = markOrderAsOutOfStock_args()
6163 
    args.read(iprot)
6164 
    iprot.readMessageEnd()
6165 
    result = markOrderAsOutOfStock_result()
6166 
    try:
6167 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6168 
    except TransactionServiceException, ex:
6169 
      result.ex = ex
6170 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6171 
    result.write(oprot)
6172 
    oprot.writeMessageEnd()
6173 
    oprot.trans.flush()
6174 
 
3064 chandransh 6175 
  def process_verifyOrder(self, seqid, iprot, oprot):
6176 
    args = verifyOrder_args()
759 chandransh 6177 
    args.read(iprot)
6178 
    iprot.readMessageEnd()
3064 chandransh 6179 
    result = verifyOrder_result()
759 chandransh 6180 
    try:
3064 chandransh 6181 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6182 
    except TransactionServiceException, ex:
6183 
      result.ex = ex
3064 chandransh 6184 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6185 
    result.write(oprot)
6186 
    oprot.writeMessageEnd()
6187 
    oprot.trans.flush()
6188 
 
3064 chandransh 6189 
  def process_acceptOrder(self, seqid, iprot, oprot):
6190 
    args = acceptOrder_args()
1113 chandransh 6191 
    args.read(iprot)
6192 
    iprot.readMessageEnd()
3064 chandransh 6193 
    result = acceptOrder_result()
1113 chandransh 6194 
    try:
3064 chandransh 6195 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6196 
    except TransactionServiceException, ex:
6197 
      result.ex = ex
3064 chandransh 6198 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 6199 
    result.write(oprot)
6200 
    oprot.writeMessageEnd()
6201 
    oprot.trans.flush()
6202 
 
3064 chandransh 6203 
  def process_addBillingDetails(self, seqid, iprot, oprot):
6204 
    args = addBillingDetails_args()
1135 chandransh 6205 
    args.read(iprot)
6206 
    iprot.readMessageEnd()
3064 chandransh 6207 
    result = addBillingDetails_result()
1135 chandransh 6208 
    try:
5110 mandeep.dh 6209 
      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 6210 
    except TransactionServiceException, ex:
6211 
      result.ex = ex
3064 chandransh 6212 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 6213 
    result.write(oprot)
6214 
    oprot.writeMessageEnd()
6215 
    oprot.trans.flush()
6216 
 
4579 rajveer 6217 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
6218 
    args = addInvoiceNumber_args()
6219 
    args.read(iprot)
6220 
    iprot.readMessageEnd()
6221 
    result = addInvoiceNumber_result()
6222 
    try:
4763 rajveer 6223 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 6224 
    except TransactionServiceException, ex:
6225 
      result.ex = ex
6226 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
6227 
    result.write(oprot)
6228 
    oprot.writeMessageEnd()
6229 
    oprot.trans.flush()
6230 
 
4410 rajveer 6231 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
6232 
    args = markOrdersAsShippedFromWarehouse_args()
6233 
    args.read(iprot)
6234 
    iprot.readMessageEnd()
6235 
    result = markOrdersAsShippedFromWarehouse_result()
6236 
    try:
4789 rajveer 6237 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 6238 
    except TransactionServiceException, ex:
6239 
      result.ex = ex
6240 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
6241 
    result.write(oprot)
6242 
    oprot.writeMessageEnd()
6243 
    oprot.trans.flush()
6244 
 
5676 rajveer 6245 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
6246 
    args = markOrdersAsReturnedFromStore_args()
6247 
    args.read(iprot)
6248 
    iprot.readMessageEnd()
6249 
    result = markOrdersAsReturnedFromStore_result()
6250 
    try:
5713 rajveer 6251 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 6252 
    except TransactionServiceException, ex:
6253 
      result.ex = ex
6254 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
6255 
    result.write(oprot)
6256 
    oprot.writeMessageEnd()
6257 
    oprot.trans.flush()
6258 
 
3064 chandransh 6259 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
6260 
    args = markOrdersAsPickedUp_args()
304 ashish 6261 
    args.read(iprot)
6262 
    iprot.readMessageEnd()
3064 chandransh 6263 
    result = markOrdersAsPickedUp_result()
6264 
    try:
4910 phani.kuma 6265 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 6266 
    except TransactionServiceException, ex:
6267 
      result.ex = ex
6268 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 6269 
    result.write(oprot)
6270 
    oprot.writeMessageEnd()
6271 
    oprot.trans.flush()
94 ashish 6272 
 
4910 phani.kuma 6273 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
6274 
    args = getOrdersNotPickedUp_args()
6275 
    args.read(iprot)
6276 
    iprot.readMessageEnd()
6277 
    result = getOrdersNotPickedUp_result()
6278 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
6279 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
6280 
    result.write(oprot)
6281 
    oprot.writeMessageEnd()
6282 
    oprot.trans.flush()
6283 
 
3064 chandransh 6284 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
6285 
    args = markOrdersAsDelivered_args()
304 ashish 6286 
    args.read(iprot)
6287 
    iprot.readMessageEnd()
3064 chandransh 6288 
    result = markOrdersAsDelivered_result()
6289 
    try:
6290 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
6291 
    except TransactionServiceException, ex:
6292 
      result.ex = ex
6293 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 6294 
    result.write(oprot)
6295 
    oprot.writeMessageEnd()
6296 
    oprot.trans.flush()
6297 
 
4910 phani.kuma 6298 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
6299 
    args = markAsRTOrders_args()
1596 ankur.sing 6300 
    args.read(iprot)
6301 
    iprot.readMessageEnd()
4910 phani.kuma 6302 
    result = markAsRTOrders_result()
3064 chandransh 6303 
    try:
4910 phani.kuma 6304 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 6305 
    except TransactionServiceException, ex:
6306 
      result.ex = ex
4910 phani.kuma 6307 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 6308 
    result.write(oprot)
6309 
    oprot.writeMessageEnd()
6310 
    oprot.trans.flush()
304 ashish 6311 
 
4910 phani.kuma 6312 
  def process_getRTOrders(self, seqid, iprot, oprot):
6313 
    args = getRTOrders_args()
6314 
    args.read(iprot)
6315 
    iprot.readMessageEnd()
6316 
    result = getRTOrders_result()
6317 
    result.success = self._handler.getRTOrders(args.providerId)
6318 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
6319 
    result.write(oprot)
6320 
    oprot.writeMessageEnd()
6321 
    oprot.trans.flush()
6322 
 
3064 chandransh 6323 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
6324 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 6325 
    args.read(iprot)
6326 
    iprot.readMessageEnd()
3064 chandransh 6327 
    result = updateNonDeliveryReason_result()
6328 
    try:
4910 phani.kuma 6329 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 6330 
    except TransactionServiceException, ex:
6331 
      result.ex = ex
6332 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 6333 
    result.write(oprot)
6334 
    oprot.writeMessageEnd()
6335 
    oprot.trans.flush()
1596 ankur.sing 6336 
 
4910 phani.kuma 6337 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
6338 
    args = getNonDeliveredOrdersbyCourier_args()
6339 
    args.read(iprot)
6340 
    iprot.readMessageEnd()
6341 
    result = getNonDeliveredOrdersbyCourier_result()
6342 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
6343 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
6344 
    result.write(oprot)
6345 
    oprot.writeMessageEnd()
6346 
    oprot.trans.flush()
6347 
 
6348 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
6349 
    args = markOrdersAsLocalConnected_args()
6350 
    args.read(iprot)
6351 
    iprot.readMessageEnd()
6352 
    result = markOrdersAsLocalConnected_result()
6353 
    try:
6354 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
6355 
    except TransactionServiceException, ex:
6356 
      result.ex = ex
6357 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
6358 
    result.write(oprot)
6359 
    oprot.writeMessageEnd()
6360 
    oprot.trans.flush()
6361 
 
6362 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
6363 
    args = getOrdersNotLocalConnected_args()
6364 
    args.read(iprot)
6365 
    iprot.readMessageEnd()
6366 
    result = getOrdersNotLocalConnected_result()
6367 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
6368 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
6369 
    result.write(oprot)
6370 
    oprot.writeMessageEnd()
6371 
    oprot.trans.flush()
6372 
 
6373 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
6374 
    args = markOrdersAsDestinationCityReached_args()
6375 
    args.read(iprot)
6376 
    iprot.readMessageEnd()
6377 
    result = markOrdersAsDestinationCityReached_result()
6378 
    try:
6379 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
6380 
    except TransactionServiceException, ex:
6381 
      result.ex = ex
6382 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
6383 
    result.write(oprot)
6384 
    oprot.writeMessageEnd()
6385 
    oprot.trans.flush()
6386 
 
6387 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
6388 
    args = markOrdersAsFirstDeliveryAttempted_args()
6389 
    args.read(iprot)
6390 
    iprot.readMessageEnd()
6391 
    result = markOrdersAsFirstDeliveryAttempted_result()
6392 
    try:
6393 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
6394 
    except TransactionServiceException, ex:
6395 
      result.ex = ex
6396 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
6397 
    result.write(oprot)
6398 
    oprot.writeMessageEnd()
6399 
    oprot.trans.flush()
6400 
 
3064 chandransh 6401 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
6402 
    args = getUndeliveredOrders_args()
1627 ankur.sing 6403 
    args.read(iprot)
6404 
    iprot.readMessageEnd()
3064 chandransh 6405 
    result = getUndeliveredOrders_result()
6406 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
6407 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 6408 
    result.write(oprot)
6409 
    oprot.writeMessageEnd()
6410 
    oprot.trans.flush()
6411 
 
4783 phani.kuma 6412 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
6413 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
6414 
    args.read(iprot)
6415 
    iprot.readMessageEnd()
6416 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
6417 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
6418 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
6419 
    result.write(oprot)
6420 
    oprot.writeMessageEnd()
6421 
    oprot.trans.flush()
6422 
 
2536 chandransh 6423 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
6424 
    args = toggleDOAFlag_args()
6425 
    args.read(iprot)
6426 
    iprot.readMessageEnd()
6427 
    result = toggleDOAFlag_result()
6428 
    try:
6429 
      result.success = self._handler.toggleDOAFlag(args.orderId)
6430 
    except TransactionServiceException, ex:
6431 
      result.ex = ex
6432 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
6433 
    result.write(oprot)
6434 
    oprot.writeMessageEnd()
6435 
    oprot.trans.flush()
1886 ankur.sing 6436 
 
4712 rajveer 6437 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
6438 
    args = markOrderAsDelivered_args()
6439 
    args.read(iprot)
6440 
    iprot.readMessageEnd()
6441 
    result = markOrderAsDelivered_result()
6442 
    try:
6443 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
6444 
    except TransactionServiceException, ex:
6445 
      result.ex = ex
6446 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
6447 
    result.write(oprot)
6448 
    oprot.writeMessageEnd()
6449 
    oprot.trans.flush()
6450 
 
5553 rajveer 6451 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
6452 
    args = markOrderAsReceivedAtStore_args()
6453 
    args.read(iprot)
6454 
    iprot.readMessageEnd()
6455 
    result = markOrderAsReceivedAtStore_result()
6456 
    try:
6457 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
6458 
    except TransactionServiceException, ex:
6459 
      result.ex = ex
6460 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
6461 
    result.write(oprot)
6462 
    oprot.writeMessageEnd()
6463 
    oprot.trans.flush()
6464 
 
4454 rajveer 6465 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
6466 
    args = markOrderDoaRequestReceived_args()
6467 
    args.read(iprot)
6468 
    iprot.readMessageEnd()
6469 
    result = markOrderDoaRequestReceived_result()
6470 
    try:
6471 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
6472 
    except TransactionServiceException, ex:
6473 
      result.ex = ex
6474 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
6475 
    result.write(oprot)
6476 
    oprot.writeMessageEnd()
6477 
    oprot.trans.flush()
6478 
 
6479 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
6480 
    args = markOrderDoaRequestAuthorized_args()
6481 
    args.read(iprot)
6482 
    iprot.readMessageEnd()
6483 
    result = markOrderDoaRequestAuthorized_result()
6484 
    try:
6485 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
6486 
    except TransactionServiceException, ex:
6487 
      result.ex = ex
6488 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
6489 
    result.write(oprot)
6490 
    oprot.writeMessageEnd()
6491 
    oprot.trans.flush()
6492 
 
4488 rajveer 6493 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
6494 
    args = markOrderReturnRequestReceived_args()
6495 
    args.read(iprot)
6496 
    iprot.readMessageEnd()
6497 
    result = markOrderReturnRequestReceived_result()
6498 
    try:
6499 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
6500 
    except TransactionServiceException, ex:
6501 
      result.ex = ex
6502 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
6503 
    result.write(oprot)
6504 
    oprot.writeMessageEnd()
6505 
    oprot.trans.flush()
6506 
 
6507 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
6508 
    args = markOrderReturnRequestAuthorized_args()
6509 
    args.read(iprot)
6510 
    iprot.readMessageEnd()
6511 
    result = markOrderReturnRequestAuthorized_result()
6512 
    try:
6513 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
6514 
    except TransactionServiceException, ex:
6515 
      result.ex = ex
6516 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
6517 
    result.write(oprot)
6518 
    oprot.writeMessageEnd()
6519 
    oprot.trans.flush()
6520 
 
2536 chandransh 6521 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
6522 
    args = requestPickupNumber_args()
6523 
    args.read(iprot)
6524 
    iprot.readMessageEnd()
6525 
    result = requestPickupNumber_result()
6526 
    try:
4579 rajveer 6527 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 6528 
    except TransactionServiceException, ex:
6529 
      result.ex = ex
6530 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
6531 
    result.write(oprot)
6532 
    oprot.writeMessageEnd()
6533 
    oprot.trans.flush()
6534 
 
6535 
  def process_authorizePickup(self, seqid, iprot, oprot):
6536 
    args = authorizePickup_args()
6537 
    args.read(iprot)
6538 
    iprot.readMessageEnd()
6539 
    result = authorizePickup_result()
6540 
    try:
4602 rajveer 6541 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 6542 
    except TransactionServiceException, ex:
6543 
      result.ex = ex
6544 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
6545 
    result.write(oprot)
6546 
    oprot.writeMessageEnd()
6547 
    oprot.trans.flush()
6548 
 
2764 chandransh 6549 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
6550 
    args = markDoasAsPickedUp_args()
6551 
    args.read(iprot)
6552 
    iprot.readMessageEnd()
6553 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 6554 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 6555 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
6556 
    result.write(oprot)
6557 
    oprot.writeMessageEnd()
6558 
    oprot.trans.flush()
6559 
 
4910 phani.kuma 6560 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
6561 
    args = getDoasNotPickedUp_args()
6562 
    args.read(iprot)
6563 
    iprot.readMessageEnd()
6564 
    result = getDoasNotPickedUp_result()
6565 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
6566 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
6567 
    result.write(oprot)
6568 
    oprot.writeMessageEnd()
6569 
    oprot.trans.flush()
6570 
 
4741 phani.kuma 6571 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
6572 
    args = markReturnOrdersAsPickedUp_args()
6573 
    args.read(iprot)
6574 
    iprot.readMessageEnd()
6575 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 6576 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 6577 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
6578 
    result.write(oprot)
6579 
    oprot.writeMessageEnd()
6580 
    oprot.trans.flush()
6581 
 
4910 phani.kuma 6582 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
6583 
    args = getReturnOrdersNotPickedUp_args()
6584 
    args.read(iprot)
6585 
    iprot.readMessageEnd()
6586 
    result = getReturnOrdersNotPickedUp_result()
6587 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
6588 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
6589 
    result.write(oprot)
6590 
    oprot.writeMessageEnd()
6591 
    oprot.trans.flush()
6592 
 
2616 chandransh 6593 
  def process_receiveReturn(self, seqid, iprot, oprot):
6594 
    args = receiveReturn_args()
2591 chandransh 6595 
    args.read(iprot)
6596 
    iprot.readMessageEnd()
2616 chandransh 6597 
    result = receiveReturn_result()
2591 chandransh 6598 
    try:
4479 rajveer 6599 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 6600 
    except TransactionServiceException, ex:
6601 
      result.ex = ex
2616 chandransh 6602 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 6603 
    result.write(oprot)
6604 
    oprot.writeMessageEnd()
6605 
    oprot.trans.flush()
2536 chandransh 6606 
 
2591 chandransh 6607 
  def process_validateDoa(self, seqid, iprot, oprot):
6608 
    args = validateDoa_args()
6609 
    args.read(iprot)
6610 
    iprot.readMessageEnd()
6611 
    result = validateDoa_result()
6612 
    try:
6613 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
6614 
    except TransactionServiceException, ex:
6615 
      result.ex = ex
6616 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
6617 
    result.write(oprot)
6618 
    oprot.writeMessageEnd()
6619 
    oprot.trans.flush()
6620 
 
4495 rajveer 6621 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
6622 
    args = validateReturnProduct_args()
6623 
    args.read(iprot)
6624 
    iprot.readMessageEnd()
6625 
    result = validateReturnProduct_result()
6626 
    try:
6627 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
6628 
    except TransactionServiceException, ex:
6629 
      result.ex = ex
6630 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
6631 
    result.write(oprot)
6632 
    oprot.writeMessageEnd()
6633 
    oprot.trans.flush()
6634 
 
2616 chandransh 6635 
  def process_reshipOrder(self, seqid, iprot, oprot):
6636 
    args = reshipOrder_args()
6637 
    args.read(iprot)
6638 
    iprot.readMessageEnd()
6639 
    result = reshipOrder_result()
6640 
    try:
6641 
      result.success = self._handler.reshipOrder(args.orderId)
6642 
    except TransactionServiceException, ex:
6643 
      result.ex = ex
6644 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
6645 
    result.write(oprot)
6646 
    oprot.writeMessageEnd()
6647 
    oprot.trans.flush()
2591 chandransh 6648 
 
2616 chandransh 6649 
  def process_refundOrder(self, seqid, iprot, oprot):
6650 
    args = refundOrder_args()
6651 
    args.read(iprot)
6652 
    iprot.readMessageEnd()
6653 
    result = refundOrder_result()
6654 
    try:
3226 chandransh 6655 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 6656 
    except TransactionServiceException, ex:
6657 
      result.ex = ex
6658 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
6659 
    result.write(oprot)
6660 
    oprot.writeMessageEnd()
6661 
    oprot.trans.flush()
6662 
 
2690 chandransh 6663 
  def process_getReturnOrders(self, seqid, iprot, oprot):
6664 
    args = getReturnOrders_args()
6665 
    args.read(iprot)
6666 
    iprot.readMessageEnd()
6667 
    result = getReturnOrders_result()
6668 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
6669 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
6670 
    result.write(oprot)
6671 
    oprot.writeMessageEnd()
6672 
    oprot.trans.flush()
2616 chandransh 6673 
 
5481 phani.kuma 6674 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
6675 
    args = getAllReturnOrders_args()
6676 
    args.read(iprot)
6677 
    iprot.readMessageEnd()
6678 
    result = getAllReturnOrders_result()
6679 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
6680 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
6681 
    result.write(oprot)
6682 
    oprot.writeMessageEnd()
6683 
    oprot.trans.flush()
6684 
 
2700 chandransh 6685 
  def process_getReturnOrder(self, seqid, iprot, oprot):
6686 
    args = getReturnOrder_args()
6687 
    args.read(iprot)
6688 
    iprot.readMessageEnd()
6689 
    result = getReturnOrder_result()
6690 
    try:
6691 
      result.success = self._handler.getReturnOrder(args.id)
6692 
    except TransactionServiceException, ex:
6693 
      result.ex = ex
6694 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
6695 
    result.write(oprot)
6696 
    oprot.writeMessageEnd()
6697 
    oprot.trans.flush()
6698 
 
2690 chandransh 6699 
  def process_processReturn(self, seqid, iprot, oprot):
6700 
    args = processReturn_args()
6701 
    args.read(iprot)
6702 
    iprot.readMessageEnd()
6703 
    result = processReturn_result()
6704 
    try:
6705 
      self._handler.processReturn(args.returnOrderId)
6706 
    except TransactionServiceException, ex:
6707 
      result.ex = ex
6708 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
6709 
    result.write(oprot)
6710 
    oprot.writeMessageEnd()
6711 
    oprot.trans.flush()
6712 
 
3451 chandransh 6713 
  def process_updateWeight(self, seqid, iprot, oprot):
6714 
    args = updateWeight_args()
6715 
    args.read(iprot)
6716 
    iprot.readMessageEnd()
6717 
    result = updateWeight_result()
6718 
    try:
6719 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
6720 
    except TransactionServiceException, ex:
6721 
      result.ex = ex
6722 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
6723 
    result.write(oprot)
6724 
    oprot.writeMessageEnd()
6725 
    oprot.trans.flush()
2819 chandransh 6726 
 
3469 chandransh 6727 
  def process_changeItem(self, seqid, iprot, oprot):
6728 
    args = changeItem_args()
6729 
    args.read(iprot)
6730 
    iprot.readMessageEnd()
6731 
    result = changeItem_result()
6732 
    try:
6733 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
6734 
    except TransactionServiceException, ex:
6735 
      result.ex = ex
6736 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
6737 
    result.write(oprot)
6738 
    oprot.writeMessageEnd()
6739 
    oprot.trans.flush()
3451 chandransh 6740 
 
3469 chandransh 6741 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
6742 
    args = shiftToWarehouse_args()
6743 
    args.read(iprot)
6744 
    iprot.readMessageEnd()
6745 
    result = shiftToWarehouse_result()
6746 
    try:
6747 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
6748 
    except TransactionServiceException, ex:
6749 
      result.ex = ex
6750 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
6751 
    result.write(oprot)
6752 
    oprot.writeMessageEnd()
6753 
    oprot.trans.flush()
6754 
 
3553 chandransh 6755 
  def process_addDelayReason(self, seqid, iprot, oprot):
6756 
    args = addDelayReason_args()
6757 
    args.read(iprot)
6758 
    iprot.readMessageEnd()
6759 
    result = addDelayReason_result()
6760 
    try:
4647 rajveer 6761 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 6762 
    except TransactionServiceException, ex:
6763 
      result.ex = ex
6764 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
6765 
    result.write(oprot)
6766 
    oprot.writeMessageEnd()
6767 
    oprot.trans.flush()
3469 chandransh 6768 
 
3956 chandransh 6769 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
6770 
    args = reconcileCodCollection_args()
6771 
    args.read(iprot)
6772 
    iprot.readMessageEnd()
6773 
    result = reconcileCodCollection_result()
6774 
    try:
6775 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
6776 
    except TransactionServiceException, ex:
6777 
      result.ex = ex
6778 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
6779 
    result.write(oprot)
6780 
    oprot.writeMessageEnd()
6781 
    oprot.trans.flush()
3553 chandransh 6782 
 
4008 mandeep.dh 6783 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
6784 
    args = getTransactionsRequiringExtraProcessing_args()
6785 
    args.read(iprot)
6786 
    iprot.readMessageEnd()
6787 
    result = getTransactionsRequiringExtraProcessing_result()
6788 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
6789 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
6790 
    result.write(oprot)
6791 
    oprot.writeMessageEnd()
6792 
    oprot.trans.flush()
3956 chandransh 6793 
 
4008 mandeep.dh 6794 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
6795 
    args = markTransactionAsProcessed_args()
6796 
    args.read(iprot)
6797 
    iprot.readMessageEnd()
6798 
    result = markTransactionAsProcessed_result()
6799 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
6800 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
6801 
    result.write(oprot)
6802 
    oprot.writeMessageEnd()
6803 
    oprot.trans.flush()
6804 
 
4018 chandransh 6805 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
6806 
    args = getItemWiseRiskyOrdersCount_args()
6807 
    args.read(iprot)
6808 
    iprot.readMessageEnd()
6809 
    result = getItemWiseRiskyOrdersCount_result()
6810 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
6811 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
6812 
    result.write(oprot)
6813 
    oprot.writeMessageEnd()
6814 
    oprot.trans.flush()
4008 mandeep.dh 6815 
 
4295 varun.gupt 6816 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
6817 
    args = getOrdersForItemIds_args()
6818 
    args.read(iprot)
6819 
    iprot.readMessageEnd()
6820 
    result = getOrdersForItemIds_result()
6821 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
6822 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
6823 
    result.write(oprot)
6824 
    oprot.writeMessageEnd()
6825 
    oprot.trans.flush()
6826 
 
4247 rajveer 6827 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
6828 
    args = markOrderCancellationRequestReceived_args()
6829 
    args.read(iprot)
6830 
    iprot.readMessageEnd()
6831 
    result = markOrderCancellationRequestReceived_result()
6832 
    try:
6833 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
6834 
    except TransactionServiceException, ex:
6835 
      result.ex = ex
6836 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
6837 
    result.write(oprot)
6838 
    oprot.writeMessageEnd()
6839 
    oprot.trans.flush()
4018 chandransh 6840 
 
4247 rajveer 6841 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
6842 
    args = markOrderCancellationRequestConfirmed_args()
6843 
    args.read(iprot)
6844 
    iprot.readMessageEnd()
6845 
    result = markOrderCancellationRequestConfirmed_result()
6846 
    try:
6847 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
6848 
    except TransactionServiceException, ex:
6849 
      result.ex = ex
6850 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
6851 
    result.write(oprot)
6852 
    oprot.writeMessageEnd()
6853 
    oprot.trans.flush()
6854 
 
6855 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
6856 
    args = markOrderCancellationRequestDenied_args()
6857 
    args.read(iprot)
6858 
    iprot.readMessageEnd()
6859 
    result = markOrderCancellationRequestDenied_result()
6860 
    try:
6861 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
6862 
    except TransactionServiceException, ex:
6863 
      result.ex = ex
6864 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
6865 
    result.write(oprot)
6866 
    oprot.writeMessageEnd()
6867 
    oprot.trans.flush()
6868 
 
4258 rajveer 6869 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
6870 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 6871 
    args.read(iprot)
6872 
    iprot.readMessageEnd()
4258 rajveer 6873 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 6874 
    try:
4258 rajveer 6875 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 6876 
    except TransactionServiceException, ex:
6877 
      result.ex = ex
4258 rajveer 6878 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 6879 
    result.write(oprot)
6880 
    oprot.writeMessageEnd()
6881 
    oprot.trans.flush()
6882 
 
4259 anupam.sin 6883 
  def process_refundTransaction(self, seqid, iprot, oprot):
6884 
    args = refundTransaction_args()
6885 
    args.read(iprot)
6886 
    iprot.readMessageEnd()
6887 
    result = refundTransaction_result()
6888 
    try:
6889 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
6890 
    except TransactionServiceException, ex:
6891 
      result.ex = ex
6892 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
6893 
    result.write(oprot)
6894 
    oprot.writeMessageEnd()
6895 
    oprot.trans.flush()
4247 rajveer 6896 
 
4324 mandeep.dh 6897 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
6898 
    args = updateShipmentAddress_args()
6899 
    args.read(iprot)
6900 
    iprot.readMessageEnd()
6901 
    result = updateShipmentAddress_result()
6902 
    try:
6903 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
6904 
    except TransactionServiceException, ex:
6905 
      result.ex = ex
6906 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
6907 
    result.write(oprot)
6908 
    oprot.writeMessageEnd()
6909 
    oprot.trans.flush()
6910 
 
4285 rajveer 6911 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
6912 
    args = acceptOrdersForItemId_args()
6913 
    args.read(iprot)
6914 
    iprot.readMessageEnd()
6915 
    result = acceptOrdersForItemId_result()
6916 
    try:
6917 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
6918 
    except TransactionServiceException, ex:
6919 
      result.ex = ex
6920 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
6921 
    result.write(oprot)
6922 
    oprot.writeMessageEnd()
6923 
    oprot.trans.flush()
4259 anupam.sin 6924 
 
4303 rajveer 6925 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
6926 
    args = markOrdersAsPORaised_args()
6927 
    args.read(iprot)
6928 
    iprot.readMessageEnd()
6929 
    result = markOrdersAsPORaised_result()
6930 
    try:
4369 rajveer 6931 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6932 
    except TransactionServiceException, ex:
6933 
      result.ex = ex
6934 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
6935 
    result.write(oprot)
6936 
    oprot.writeMessageEnd()
6937 
    oprot.trans.flush()
4285 rajveer 6938 
 
4303 rajveer 6939 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
6940 
    args = markOrdersAsReversalInitiated_args()
6941 
    args.read(iprot)
6942 
    iprot.readMessageEnd()
6943 
    result = markOrdersAsReversalInitiated_result()
6944 
    try:
4369 rajveer 6945 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6946 
    except TransactionServiceException, ex:
6947 
      result.ex = ex
6948 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
6949 
    result.write(oprot)
6950 
    oprot.writeMessageEnd()
6951 
    oprot.trans.flush()
6952 
 
6953 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
6954 
    args = markOrdersAsNotAvailabke_args()
6955 
    args.read(iprot)
6956 
    iprot.readMessageEnd()
6957 
    result = markOrdersAsNotAvailabke_result()
6958 
    try:
4369 rajveer 6959 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 6960 
    except TransactionServiceException, ex:
6961 
      result.ex = ex
6962 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
6963 
    result.write(oprot)
6964 
    oprot.writeMessageEnd()
6965 
    oprot.trans.flush()
6966 
 
4369 rajveer 6967 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
6968 
    args = markOrdersAsTimeout_args()
6969 
    args.read(iprot)
6970 
    iprot.readMessageEnd()
6971 
    result = markOrdersAsTimeout_result()
6972 
    try:
6973 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
6974 
    except TransactionServiceException, ex:
6975 
      result.ex = ex
6976 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
6977 
    result.write(oprot)
6978 
    oprot.writeMessageEnd()
6979 
    oprot.trans.flush()
4303 rajveer 6980 
 
4662 rajveer 6981 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
6982 
    args = markOrderAsLostInTransit_args()
6983 
    args.read(iprot)
6984 
    iprot.readMessageEnd()
6985 
    result = markOrderAsLostInTransit_result()
6986 
    try:
6987 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
6988 
    except TransactionServiceException, ex:
6989 
      result.ex = ex
6990 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
6991 
    result.write(oprot)
6992 
    oprot.writeMessageEnd()
6993 
    oprot.trans.flush()
6994 
 
4386 anupam.sin 6995 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
6996 
    args = getOrderForAwb_args()
6997 
    args.read(iprot)
6998 
    iprot.readMessageEnd()
6999 
    result = getOrderForAwb_result()
7000 
    try:
7001 
      result.success = self._handler.getOrderForAwb(args.awb)
7002 
    except TransactionServiceException, ex:
7003 
      result.ex = ex
7004 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7005 
    result.write(oprot)
7006 
    oprot.writeMessageEnd()
7007 
    oprot.trans.flush()
4369 rajveer 7008 
 
4506 phani.kuma 7009 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7010 
    args = getOrdersForProviderForStatus_args()
7011 
    args.read(iprot)
7012 
    iprot.readMessageEnd()
7013 
    result = getOrdersForProviderForStatus_result()
7014 
    try:
4910 phani.kuma 7015 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7016 
    except TransactionServiceException, ex:
7017 
      result.ex = ex
7018 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7019 
    result.write(oprot)
7020 
    oprot.writeMessageEnd()
7021 
    oprot.trans.flush()
4386 anupam.sin 7022 
 
4600 varun.gupt 7023 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7024 
    args = getBilledOrdersForVendor_args()
7025 
    args.read(iprot)
7026 
    iprot.readMessageEnd()
7027 
    result = getBilledOrdersForVendor_result()
7028 
    try:
7029 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7030 
    except TransactionServiceException, ex:
7031 
      result.ex = ex
7032 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7033 
    result.write(oprot)
7034 
    oprot.writeMessageEnd()
7035 
    oprot.trans.flush()
4506 phani.kuma 7036 
 
4607 rajveer 7037 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7038 
    args = getSlippedSippingDateOrders_args()
7039 
    args.read(iprot)
7040 
    iprot.readMessageEnd()
7041 
    result = getSlippedSippingDateOrders_result()
7042 
    try:
7043 
      result.success = self._handler.getSlippedSippingDateOrders()
7044 
    except TransactionServiceException, ex:
7045 
      result.ex = ex
7046 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7047 
    result.write(oprot)
7048 
    oprot.writeMessageEnd()
7049 
    oprot.trans.flush()
7050 
 
4709 rajveer 7051 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7052 
    args = getCancelledOrders_args()
7053 
    args.read(iprot)
7054 
    iprot.readMessageEnd()
7055 
    result = getCancelledOrders_result()
7056 
    try:
7057 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7058 
    except TransactionServiceException, ex:
7059 
      result.ex = ex
7060 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7061 
    result.write(oprot)
7062 
    oprot.writeMessageEnd()
7063 
    oprot.trans.flush()
7064 
 
4600 varun.gupt 7065 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7066 
    args = saveBluedartSettlements_args()
7067 
    args.read(iprot)
7068 
    iprot.readMessageEnd()
7069 
    result = saveBluedartSettlements_result()
7070 
    try:
7071 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7072 
    except TransactionServiceException, ex:
7073 
      result.ex = ex
7074 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7075 
    result.write(oprot)
7076 
    oprot.writeMessageEnd()
7077 
    oprot.trans.flush()
7078 
 
7079 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7080 
    args = savePaymentSettlements_args()
7081 
    args.read(iprot)
7082 
    iprot.readMessageEnd()
7083 
    result = savePaymentSettlements_result()
7084 
    try:
4905 varun.gupt 7085 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7086 
    except TransactionServiceException, ex:
7087 
      result.ex = ex
7088 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7089 
    result.write(oprot)
7090 
    oprot.writeMessageEnd()
7091 
    oprot.trans.flush()
7092 
 
7093 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7094 
    args = saveEBSSettlementSummary_args()
7095 
    args.read(iprot)
7096 
    iprot.readMessageEnd()
7097 
    result = saveEBSSettlementSummary_result()
7098 
    try:
7099 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7100 
    except TransactionServiceException, ex:
7101 
      result.ex = ex
7102 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7103 
    result.write(oprot)
7104 
    oprot.writeMessageEnd()
7105 
    oprot.trans.flush()
7106 
 
5386 phani.kuma 7107 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7108 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7109 
    args.read(iprot)
7110 
    iprot.readMessageEnd()
5386 phani.kuma 7111 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7112 
    try:
5386 phani.kuma 7113 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7114 
    except TransactionServiceException, ex:
7115 
      result.ex = ex
5386 phani.kuma 7116 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7117 
    result.write(oprot)
7118 
    oprot.writeMessageEnd()
7119 
    oprot.trans.flush()
7120 
 
5386 phani.kuma 7121 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7122 
    args = getSettlementForCod_args()
7123 
    args.read(iprot)
7124 
    iprot.readMessageEnd()
7125 
    result = getSettlementForCod_result()
7126 
    try:
7127 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7128 
    except TransactionServiceException, ex:
7129 
      result.ex = ex
7130 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7131 
    result.write(oprot)
7132 
    oprot.writeMessageEnd()
7133 
    oprot.trans.flush()
7134 
 
4600 varun.gupt 7135 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7136 
    args = getEBSSettlementSummaries_args()
7137 
    args.read(iprot)
7138 
    iprot.readMessageEnd()
7139 
    result = getEBSSettlementSummaries_result()
7140 
    try:
7141 
      result.success = self._handler.getEBSSettlementSummaries()
7142 
    except TransactionServiceException, ex:
7143 
      result.ex = ex
7144 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7145 
    result.write(oprot)
7146 
    oprot.writeMessageEnd()
7147 
    oprot.trans.flush()
7148 
 
7149 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7150 
    args = markEBSSettlementUploaded_args()
7151 
    args.read(iprot)
7152 
    iprot.readMessageEnd()
7153 
    result = markEBSSettlementUploaded_result()
7154 
    try:
7155 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7156 
    except TransactionServiceException, ex:
7157 
      result.ex = ex
7158 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7159 
    result.write(oprot)
7160 
    oprot.writeMessageEnd()
7161 
    oprot.trans.flush()
7162 
 
7163 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7164 
    args = getEBSSettlementDate_args()
7165 
    args.read(iprot)
7166 
    iprot.readMessageEnd()
7167 
    result = getEBSSettlementDate_result()
7168 
    try:
7169 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7170 
    except TransactionServiceException, ex:
7171 
      result.ex = ex
7172 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7173 
    result.write(oprot)
7174 
    oprot.writeMessageEnd()
7175 
    oprot.trans.flush()
7176 
 
4715 varun.gupt 7177 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7178 
    args = getSettlementsByDate_args()
7179 
    args.read(iprot)
7180 
    iprot.readMessageEnd()
7181 
    result = getSettlementsByDate_result()
7182 
    try:
7183 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7184 
    except TransactionServiceException, ex:
7185 
      result.ex = ex
7186 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7187 
    result.write(oprot)
7188 
    oprot.writeMessageEnd()
7189 
    oprot.trans.flush()
4600 varun.gupt 7190 
 
4715 varun.gupt 7191 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7192 
    args = getReshippedOrderIds_args()
7193 
    args.read(iprot)
7194 
    iprot.readMessageEnd()
7195 
    result = getReshippedOrderIds_result()
7196 
    try:
7197 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
7198 
    except TransactionServiceException, ex:
7199 
      result.ex = ex
7200 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
7201 
    result.write(oprot)
7202 
    oprot.writeMessageEnd()
7203 
    oprot.trans.flush()
7204 
 
5481 phani.kuma 7205 
  def process_getBilledOrders(self, seqid, iprot, oprot):
7206 
    args = getBilledOrders_args()
4875 varun.gupt 7207 
    args.read(iprot)
7208 
    iprot.readMessageEnd()
5481 phani.kuma 7209 
    result = getBilledOrders_result()
4875 varun.gupt 7210 
    try:
5481 phani.kuma 7211 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 7212 
    except TransactionServiceException, ex:
7213 
      result.ex = ex
5481 phani.kuma 7214 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 7215 
    result.write(oprot)
7216 
    oprot.writeMessageEnd()
7217 
    oprot.trans.flush()
4757 mandeep.dh 7218 
 
5031 varun.gupt 7219 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
7220 
    args = getStatusDistributionOfOrders_args()
7221 
    args.read(iprot)
7222 
    iprot.readMessageEnd()
7223 
    result = getStatusDistributionOfOrders_result()
7224 
    try:
7225 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
7226 
    except TransactionServiceException, ex:
7227 
      result.ex = ex
7228 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
7229 
    result.write(oprot)
7230 
    oprot.writeMessageEnd()
7231 
    oprot.trans.flush()
4875 varun.gupt 7232 
 
5067 varun.gupt 7233 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
7234 
    args = getOrderIdsForStatus_args()
7235 
    args.read(iprot)
7236 
    iprot.readMessageEnd()
7237 
    result = getOrderIdsForStatus_result()
7238 
    try:
7239 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
7240 
    except TransactionServiceException, ex:
7241 
      result.ex = ex
7242 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
7243 
    result.write(oprot)
7244 
    oprot.writeMessageEnd()
7245 
    oprot.trans.flush()
5031 varun.gupt 7246 
 
5348 anupam.sin 7247 
  def process_updateCODAgent(self, seqid, iprot, oprot):
7248 
    args = updateCODAgent_args()
7249 
    args.read(iprot)
7250 
    iprot.readMessageEnd()
7251 
    result = updateCODAgent_result()
7252 
    try:
7253 
      self._handler.updateCODAgent(args.agent, args.orderId)
7254 
    except TransactionServiceException, ex:
7255 
      result.ex = ex
7256 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
7257 
    result.write(oprot)
7258 
    oprot.writeMessageEnd()
7259 
    oprot.trans.flush()
7260 
 
5099 varun.gupt 7261 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
7262 
    args = updateOrderAsPaidToVendor_args()
7263 
    args.read(iprot)
7264 
    iprot.readMessageEnd()
7265 
    result = updateOrderAsPaidToVendor_result()
7266 
    try:
7267 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
7268 
    except TransactionServiceException, ex:
7269 
      result.ex = ex
7270 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
7271 
    result.write(oprot)
7272 
    oprot.writeMessageEnd()
7273 
    oprot.trans.flush()
5067 varun.gupt 7274 
 
5386 phani.kuma 7275 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
7276 
    args = updateOrderOnlyAsPaidToVendor_args()
7277 
    args.read(iprot)
7278 
    iprot.readMessageEnd()
7279 
    result = updateOrderOnlyAsPaidToVendor_result()
7280 
    try:
7281 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
7282 
    except TransactionServiceException, ex:
7283 
      result.ex = ex
7284 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
7285 
    result.write(oprot)
7286 
    oprot.writeMessageEnd()
7287 
    oprot.trans.flush()
7288 
 
5208 varun.gupt 7289 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
7290 
    args = getRefundedOrdersMarkedPaid_args()
7291 
    args.read(iprot)
7292 
    iprot.readMessageEnd()
7293 
    result = getRefundedOrdersMarkedPaid_result()
7294 
    try:
7295 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
7296 
    except TransactionServiceException, ex:
7297 
      result.ex = ex
7298 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
7299 
    result.write(oprot)
7300 
    oprot.writeMessageEnd()
7301 
    oprot.trans.flush()
5099 varun.gupt 7302 
 
5447 anupam.sin 7303 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
7304 
    args = getAllVerificationAgents_args()
7305 
    args.read(iprot)
7306 
    iprot.readMessageEnd()
7307 
    result = getAllVerificationAgents_result()
7308 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
7309 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
7310 
    result.write(oprot)
7311 
    oprot.writeMessageEnd()
7312 
    oprot.trans.flush()
5208 varun.gupt 7313 
 
5527 anupam.sin 7314 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
7315 
    args = getAllAttributesForOrderId_args()
7316 
    args.read(iprot)
7317 
    iprot.readMessageEnd()
7318 
    result = getAllAttributesForOrderId_result()
7319 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
7320 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
7321 
    result.write(oprot)
7322 
    oprot.writeMessageEnd()
7323 
    oprot.trans.flush()
5447 anupam.sin 7324 
 
5676 rajveer 7325 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
7326 
    args = setOrderAttributes_args()
7327 
    args.read(iprot)
7328 
    iprot.readMessageEnd()
7329 
    result = setOrderAttributes_result()
7330 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
7331 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
7332 
    result.write(oprot)
7333 
    oprot.writeMessageEnd()
7334 
    oprot.trans.flush()
7335 
 
5527 anupam.sin 7336 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
7337 
    args = setOrderAttributeForTransaction_args()
7338 
    args.read(iprot)
7339 
    iprot.readMessageEnd()
7340 
    result = setOrderAttributeForTransaction_result()
7341 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
7342 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
7343 
    result.write(oprot)
7344 
    oprot.writeMessageEnd()
7345 
    oprot.trans.flush()
7346 
 
5553 rajveer 7347 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
7348 
    args = getReceivePendingOrders_args()
7349 
    args.read(iprot)
7350 
    iprot.readMessageEnd()
7351 
    result = getReceivePendingOrders_result()
7352 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
7353 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
7354 
    result.write(oprot)
7355 
    oprot.writeMessageEnd()
7356 
    oprot.trans.flush()
5527 anupam.sin 7357 
 
5553 rajveer 7358 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
7359 
    args = getReceivedAtStoreOrders_args()
7360 
    args.read(iprot)
7361 
    iprot.readMessageEnd()
7362 
    result = getReceivedAtStoreOrders_result()
7363 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
7364 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
7365 
    result.write(oprot)
7366 
    oprot.writeMessageEnd()
7367 
    oprot.trans.flush()
7368 
 
5713 rajveer 7369 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
7370 
    args = getOrdersCollectionAtStore_args()
7371 
    args.read(iprot)
7372 
    iprot.readMessageEnd()
7373 
    result = getOrdersCollectionAtStore_result()
7374 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
7375 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
7376 
    result.write(oprot)
7377 
    oprot.writeMessageEnd()
7378 
    oprot.trans.flush()
7379 
 
5593 mandeep.dh 7380 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
7381 
    args = acceptOrderForItem_args()
7382 
    args.read(iprot)
7383 
    iprot.readMessageEnd()
7384 
    result = acceptOrderForItem_result()
7385 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
7386 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
7387 
    result.write(oprot)
7388 
    oprot.writeMessageEnd()
7389 
    oprot.trans.flush()
5553 rajveer 7390 
 
5593 mandeep.dh 7391 
 
94 ashish 7392 
# HELPER FUNCTIONS AND STRUCTURES
7393 
 
7394 
class createTransaction_args:
7395 
  """
7396 
  Attributes:
7397 
   - transaction
7398 
  """
7399 
 
7400 
  thrift_spec = (
7401 
    None, # 0
7402 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
7403 
  )
7404 
 
7405 
  def __init__(self, transaction=None,):
7406 
    self.transaction = transaction
7407 
 
7408 
  def read(self, iprot):
7409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7411 
      return
7412 
    iprot.readStructBegin()
7413 
    while True:
7414 
      (fname, ftype, fid) = iprot.readFieldBegin()
7415 
      if ftype == TType.STOP:
7416 
        break
7417 
      if fid == 1:
7418 
        if ftype == TType.STRUCT:
7419 
          self.transaction = Transaction()
7420 
          self.transaction.read(iprot)
7421 
        else:
7422 
          iprot.skip(ftype)
7423 
      else:
7424 
        iprot.skip(ftype)
7425 
      iprot.readFieldEnd()
7426 
    iprot.readStructEnd()
7427 
 
7428 
  def write(self, oprot):
7429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7431 
      return
7432 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 7433 
    if self.transaction is not None:
94 ashish 7434 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
7435 
      self.transaction.write(oprot)
7436 
      oprot.writeFieldEnd()
7437 
    oprot.writeFieldStop()
7438 
    oprot.writeStructEnd()
7439 
 
3431 rajveer 7440 
  def validate(self):
7441 
    return
7442 
 
7443 
 
94 ashish 7444 
  def __repr__(self):
7445 
    L = ['%s=%r' % (key, value)
7446 
      for key, value in self.__dict__.iteritems()]
7447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7448 
 
7449 
  def __eq__(self, other):
7450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7451 
 
7452 
  def __ne__(self, other):
7453 
    return not (self == other)
7454 
 
7455 
class createTransaction_result:
7456 
  """
7457 
  Attributes:
132 ashish 7458 
   - success
94 ashish 7459 
   - ex
7460 
  """
7461 
 
7462 
  thrift_spec = (
132 ashish 7463 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 7464 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7465 
  )
7466 
 
132 ashish 7467 
  def __init__(self, success=None, ex=None,):
7468 
    self.success = success
94 ashish 7469 
    self.ex = ex
7470 
 
7471 
  def read(self, iprot):
7472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7474 
      return
7475 
    iprot.readStructBegin()
7476 
    while True:
7477 
      (fname, ftype, fid) = iprot.readFieldBegin()
7478 
      if ftype == TType.STOP:
7479 
        break
132 ashish 7480 
      if fid == 0:
7481 
        if ftype == TType.I64:
7482 
          self.success = iprot.readI64();
7483 
        else:
7484 
          iprot.skip(ftype)
7485 
      elif fid == 1:
94 ashish 7486 
        if ftype == TType.STRUCT:
7487 
          self.ex = TransactionServiceException()
7488 
          self.ex.read(iprot)
7489 
        else:
7490 
          iprot.skip(ftype)
7491 
      else:
7492 
        iprot.skip(ftype)
7493 
      iprot.readFieldEnd()
7494 
    iprot.readStructEnd()
7495 
 
7496 
  def write(self, oprot):
7497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7499 
      return
7500 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 7501 
    if self.success is not None:
132 ashish 7502 
      oprot.writeFieldBegin('success', TType.I64, 0)
7503 
      oprot.writeI64(self.success)
7504 
      oprot.writeFieldEnd()
3431 rajveer 7505 
    if self.ex is not None:
94 ashish 7506 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7507 
      self.ex.write(oprot)
7508 
      oprot.writeFieldEnd()
7509 
    oprot.writeFieldStop()
7510 
    oprot.writeStructEnd()
7511 
 
3431 rajveer 7512 
  def validate(self):
7513 
    return
7514 
 
7515 
 
94 ashish 7516 
  def __repr__(self):
7517 
    L = ['%s=%r' % (key, value)
7518 
      for key, value in self.__dict__.iteritems()]
7519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7520 
 
7521 
  def __eq__(self, other):
7522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7523 
 
7524 
  def __ne__(self, other):
7525 
    return not (self == other)
7526 
 
7527 
class getTransaction_args:
7528 
  """
7529 
  Attributes:
7530 
   - id
7531 
  """
7532 
 
7533 
  thrift_spec = (
7534 
    None, # 0
7535 
    (1, TType.I64, 'id', None, None, ), # 1
7536 
  )
7537 
 
7538 
  def __init__(self, id=None,):
7539 
    self.id = id
7540 
 
7541 
  def read(self, iprot):
7542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7544 
      return
7545 
    iprot.readStructBegin()
7546 
    while True:
7547 
      (fname, ftype, fid) = iprot.readFieldBegin()
7548 
      if ftype == TType.STOP:
7549 
        break
7550 
      if fid == 1:
7551 
        if ftype == TType.I64:
7552 
          self.id = iprot.readI64();
7553 
        else:
7554 
          iprot.skip(ftype)
7555 
      else:
7556 
        iprot.skip(ftype)
7557 
      iprot.readFieldEnd()
7558 
    iprot.readStructEnd()
7559 
 
7560 
  def write(self, oprot):
7561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7563 
      return
7564 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 7565 
    if self.id is not None:
94 ashish 7566 
      oprot.writeFieldBegin('id', TType.I64, 1)
7567 
      oprot.writeI64(self.id)
7568 
      oprot.writeFieldEnd()
7569 
    oprot.writeFieldStop()
7570 
    oprot.writeStructEnd()
7571 
 
3431 rajveer 7572 
  def validate(self):
7573 
    return
7574 
 
7575 
 
94 ashish 7576 
  def __repr__(self):
7577 
    L = ['%s=%r' % (key, value)
7578 
      for key, value in self.__dict__.iteritems()]
7579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7580 
 
7581 
  def __eq__(self, other):
7582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7583 
 
7584 
  def __ne__(self, other):
7585 
    return not (self == other)
7586 
 
7587 
class getTransaction_result:
7588 
  """
7589 
  Attributes:
7590 
   - success
7591 
   - ex
7592 
  """
7593 
 
7594 
  thrift_spec = (
7595 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
7596 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7597 
  )
7598 
 
7599 
  def __init__(self, success=None, ex=None,):
7600 
    self.success = success
7601 
    self.ex = ex
7602 
 
7603 
  def read(self, iprot):
7604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7606 
      return
7607 
    iprot.readStructBegin()
7608 
    while True:
7609 
      (fname, ftype, fid) = iprot.readFieldBegin()
7610 
      if ftype == TType.STOP:
7611 
        break
7612 
      if fid == 0:
7613 
        if ftype == TType.STRUCT:
7614 
          self.success = Transaction()
7615 
          self.success.read(iprot)
7616 
        else:
7617 
          iprot.skip(ftype)
7618 
      elif fid == 1:
7619 
        if ftype == TType.STRUCT:
7620 
          self.ex = TransactionServiceException()
7621 
          self.ex.read(iprot)
7622 
        else:
7623 
          iprot.skip(ftype)
7624 
      else:
7625 
        iprot.skip(ftype)
7626 
      iprot.readFieldEnd()
7627 
    iprot.readStructEnd()
7628 
 
7629 
  def write(self, oprot):
7630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7632 
      return
7633 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 7634 
    if self.success is not None:
94 ashish 7635 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7636 
      self.success.write(oprot)
7637 
      oprot.writeFieldEnd()
3431 rajveer 7638 
    if self.ex is not None:
94 ashish 7639 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7640 
      self.ex.write(oprot)
7641 
      oprot.writeFieldEnd()
7642 
    oprot.writeFieldStop()
7643 
    oprot.writeStructEnd()
7644 
 
3431 rajveer 7645 
  def validate(self):
7646 
    return
7647 
 
7648 
 
94 ashish 7649 
  def __repr__(self):
7650 
    L = ['%s=%r' % (key, value)
7651 
      for key, value in self.__dict__.iteritems()]
7652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7653 
 
7654 
  def __eq__(self, other):
7655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7656 
 
7657 
  def __ne__(self, other):
7658 
    return not (self == other)
7659 
 
7660 
class getTransactionsForCustomer_args:
7661 
  """
7662 
  Attributes:
7663 
   - customerId
7664 
   - from_date
7665 
   - to_date
7666 
   - status
7667 
  """
7668 
 
7669 
  thrift_spec = (
7670 
    None, # 0
7671 
    (1, TType.I64, 'customerId', None, None, ), # 1
7672 
    (2, TType.I64, 'from_date', None, None, ), # 2
7673 
    (3, TType.I64, 'to_date', None, None, ), # 3
7674 
    (4, TType.I32, 'status', None, None, ), # 4
7675 
  )
7676 
 
7677 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
7678 
    self.customerId = customerId
7679 
    self.from_date = from_date
7680 
    self.to_date = to_date
7681 
    self.status = status
7682 
 
7683 
  def read(self, iprot):
7684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7686 
      return
7687 
    iprot.readStructBegin()
7688 
    while True:
7689 
      (fname, ftype, fid) = iprot.readFieldBegin()
7690 
      if ftype == TType.STOP:
7691 
        break
7692 
      if fid == 1:
7693 
        if ftype == TType.I64:
7694 
          self.customerId = iprot.readI64();
7695 
        else:
7696 
          iprot.skip(ftype)
7697 
      elif fid == 2:
7698 
        if ftype == TType.I64:
7699 
          self.from_date = iprot.readI64();
7700 
        else:
7701 
          iprot.skip(ftype)
7702 
      elif fid == 3:
7703 
        if ftype == TType.I64:
7704 
          self.to_date = iprot.readI64();
7705 
        else:
7706 
          iprot.skip(ftype)
7707 
      elif fid == 4:
7708 
        if ftype == TType.I32:
7709 
          self.status = iprot.readI32();
7710 
        else:
7711 
          iprot.skip(ftype)
7712 
      else:
7713 
        iprot.skip(ftype)
7714 
      iprot.readFieldEnd()
7715 
    iprot.readStructEnd()
7716 
 
7717 
  def write(self, oprot):
7718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7720 
      return
7721 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 7722 
    if self.customerId is not None:
94 ashish 7723 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
7724 
      oprot.writeI64(self.customerId)
7725 
      oprot.writeFieldEnd()
3431 rajveer 7726 
    if self.from_date is not None:
94 ashish 7727 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
7728 
      oprot.writeI64(self.from_date)
7729 
      oprot.writeFieldEnd()
3431 rajveer 7730 
    if self.to_date is not None:
94 ashish 7731 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
7732 
      oprot.writeI64(self.to_date)
7733 
      oprot.writeFieldEnd()
3431 rajveer 7734 
    if self.status is not None:
94 ashish 7735 
      oprot.writeFieldBegin('status', TType.I32, 4)
7736 
      oprot.writeI32(self.status)
7737 
      oprot.writeFieldEnd()
7738 
    oprot.writeFieldStop()
7739 
    oprot.writeStructEnd()
7740 
 
3431 rajveer 7741 
  def validate(self):
7742 
    return
7743 
 
7744 
 
94 ashish 7745 
  def __repr__(self):
7746 
    L = ['%s=%r' % (key, value)
7747 
      for key, value in self.__dict__.iteritems()]
7748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7749 
 
7750 
  def __eq__(self, other):
7751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7752 
 
7753 
  def __ne__(self, other):
7754 
    return not (self == other)
7755 
 
7756 
class getTransactionsForCustomer_result:
7757 
  """
7758 
  Attributes:
7759 
   - success
7760 
   - ex
7761 
  """
7762 
 
7763 
  thrift_spec = (
7764 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7765 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7766 
  )
7767 
 
7768 
  def __init__(self, success=None, ex=None,):
7769 
    self.success = success
7770 
    self.ex = ex
7771 
 
7772 
  def read(self, iprot):
7773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7775 
      return
7776 
    iprot.readStructBegin()
7777 
    while True:
7778 
      (fname, ftype, fid) = iprot.readFieldBegin()
7779 
      if ftype == TType.STOP:
7780 
        break
7781 
      if fid == 0:
7782 
        if ftype == TType.LIST:
7783 
          self.success = []
5031 varun.gupt 7784 
          (_etype66, _size63) = iprot.readListBegin()
7785 
          for _i67 in xrange(_size63):
7786 
            _elem68 = Transaction()
7787 
            _elem68.read(iprot)
7788 
            self.success.append(_elem68)
94 ashish 7789 
          iprot.readListEnd()
7790 
        else:
7791 
          iprot.skip(ftype)
7792 
      elif fid == 1:
7793 
        if ftype == TType.STRUCT:
7794 
          self.ex = TransactionServiceException()
7795 
          self.ex.read(iprot)
7796 
        else:
7797 
          iprot.skip(ftype)
7798 
      else:
7799 
        iprot.skip(ftype)
7800 
      iprot.readFieldEnd()
7801 
    iprot.readStructEnd()
7802 
 
7803 
  def write(self, oprot):
7804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7806 
      return
7807 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 7808 
    if self.success is not None:
94 ashish 7809 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7810 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7811 
      for iter69 in self.success:
7812 
        iter69.write(oprot)
94 ashish 7813 
      oprot.writeListEnd()
7814 
      oprot.writeFieldEnd()
3431 rajveer 7815 
    if self.ex is not None:
94 ashish 7816 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7817 
      self.ex.write(oprot)
7818 
      oprot.writeFieldEnd()
7819 
    oprot.writeFieldStop()
7820 
    oprot.writeStructEnd()
7821 
 
3431 rajveer 7822 
  def validate(self):
7823 
    return
7824 
 
7825 
 
94 ashish 7826 
  def __repr__(self):
7827 
    L = ['%s=%r' % (key, value)
7828 
      for key, value in self.__dict__.iteritems()]
7829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7830 
 
7831 
  def __eq__(self, other):
7832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7833 
 
7834 
  def __ne__(self, other):
7835 
    return not (self == other)
7836 
 
132 ashish 7837 
class getTransactionsForShoppingCartId_args:
7838 
  """
7839 
  Attributes:
7840 
   - shoppingCartId
7841 
  """
7842 
 
7843 
  thrift_spec = (
7844 
    None, # 0
7845 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
7846 
  )
7847 
 
7848 
  def __init__(self, shoppingCartId=None,):
7849 
    self.shoppingCartId = shoppingCartId
7850 
 
7851 
  def read(self, iprot):
7852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7854 
      return
7855 
    iprot.readStructBegin()
7856 
    while True:
7857 
      (fname, ftype, fid) = iprot.readFieldBegin()
7858 
      if ftype == TType.STOP:
7859 
        break
7860 
      if fid == 1:
7861 
        if ftype == TType.I64:
7862 
          self.shoppingCartId = iprot.readI64();
7863 
        else:
7864 
          iprot.skip(ftype)
7865 
      else:
7866 
        iprot.skip(ftype)
7867 
      iprot.readFieldEnd()
7868 
    iprot.readStructEnd()
7869 
 
7870 
  def write(self, oprot):
7871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7873 
      return
7874 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 7875 
    if self.shoppingCartId is not None:
132 ashish 7876 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
7877 
      oprot.writeI64(self.shoppingCartId)
7878 
      oprot.writeFieldEnd()
7879 
    oprot.writeFieldStop()
7880 
    oprot.writeStructEnd()
7881 
 
3431 rajveer 7882 
  def validate(self):
7883 
    return
7884 
 
7885 
 
132 ashish 7886 
  def __repr__(self):
7887 
    L = ['%s=%r' % (key, value)
7888 
      for key, value in self.__dict__.iteritems()]
7889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7890 
 
7891 
  def __eq__(self, other):
7892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7893 
 
7894 
  def __ne__(self, other):
7895 
    return not (self == other)
7896 
 
7897 
class getTransactionsForShoppingCartId_result:
7898 
  """
7899 
  Attributes:
7900 
   - success
7901 
   - ex
7902 
  """
7903 
 
7904 
  thrift_spec = (
7905 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
7906 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7907 
  )
7908 
 
7909 
  def __init__(self, success=None, ex=None,):
7910 
    self.success = success
7911 
    self.ex = ex
7912 
 
7913 
  def read(self, iprot):
7914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7916 
      return
7917 
    iprot.readStructBegin()
7918 
    while True:
7919 
      (fname, ftype, fid) = iprot.readFieldBegin()
7920 
      if ftype == TType.STOP:
7921 
        break
7922 
      if fid == 0:
7923 
        if ftype == TType.LIST:
7924 
          self.success = []
5031 varun.gupt 7925 
          (_etype73, _size70) = iprot.readListBegin()
7926 
          for _i74 in xrange(_size70):
7927 
            _elem75 = Transaction()
7928 
            _elem75.read(iprot)
7929 
            self.success.append(_elem75)
132 ashish 7930 
          iprot.readListEnd()
7931 
        else:
7932 
          iprot.skip(ftype)
7933 
      elif fid == 1:
7934 
        if ftype == TType.STRUCT:
7935 
          self.ex = TransactionServiceException()
7936 
          self.ex.read(iprot)
7937 
        else:
7938 
          iprot.skip(ftype)
7939 
      else:
7940 
        iprot.skip(ftype)
7941 
      iprot.readFieldEnd()
7942 
    iprot.readStructEnd()
7943 
 
7944 
  def write(self, oprot):
7945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7947 
      return
7948 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 7949 
    if self.success is not None:
132 ashish 7950 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7951 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 7952 
      for iter76 in self.success:
7953 
        iter76.write(oprot)
132 ashish 7954 
      oprot.writeListEnd()
7955 
      oprot.writeFieldEnd()
3431 rajveer 7956 
    if self.ex is not None:
132 ashish 7957 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7958 
      self.ex.write(oprot)
7959 
      oprot.writeFieldEnd()
7960 
    oprot.writeFieldStop()
7961 
    oprot.writeStructEnd()
7962 
 
3431 rajveer 7963 
  def validate(self):
7964 
    return
7965 
 
7966 
 
132 ashish 7967 
  def __repr__(self):
7968 
    L = ['%s=%r' % (key, value)
7969 
      for key, value in self.__dict__.iteritems()]
7970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7971 
 
7972 
  def __eq__(self, other):
7973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7974 
 
7975 
  def __ne__(self, other):
7976 
    return not (self == other)
7977 
 
94 ashish 7978 
class getTransactionStatus_args:
7979 
  """
7980 
  Attributes:
7981 
   - transactionId
7982 
  """
7983 
 
7984 
  thrift_spec = (
7985 
    None, # 0
7986 
    (1, TType.I64, 'transactionId', None, None, ), # 1
7987 
  )
7988 
 
7989 
  def __init__(self, transactionId=None,):
7990 
    self.transactionId = transactionId
7991 
 
7992 
  def read(self, iprot):
7993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7995 
      return
7996 
    iprot.readStructBegin()
7997 
    while True:
7998 
      (fname, ftype, fid) = iprot.readFieldBegin()
7999 
      if ftype == TType.STOP:
8000 
        break
8001 
      if fid == 1:
8002 
        if ftype == TType.I64:
8003 
          self.transactionId = iprot.readI64();
8004 
        else:
8005 
          iprot.skip(ftype)
8006 
      else:
8007 
        iprot.skip(ftype)
8008 
      iprot.readFieldEnd()
8009 
    iprot.readStructEnd()
8010 
 
8011 
  def write(self, oprot):
8012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8014 
      return
8015 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 8016 
    if self.transactionId is not None:
94 ashish 8017 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8018 
      oprot.writeI64(self.transactionId)
8019 
      oprot.writeFieldEnd()
8020 
    oprot.writeFieldStop()
8021 
    oprot.writeStructEnd()
8022 
 
3431 rajveer 8023 
  def validate(self):
8024 
    return
8025 
 
8026 
 
94 ashish 8027 
  def __repr__(self):
8028 
    L = ['%s=%r' % (key, value)
8029 
      for key, value in self.__dict__.iteritems()]
8030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8031 
 
8032 
  def __eq__(self, other):
8033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8034 
 
8035 
  def __ne__(self, other):
8036 
    return not (self == other)
8037 
 
8038 
class getTransactionStatus_result:
8039 
  """
8040 
  Attributes:
8041 
   - success
8042 
   - ex
8043 
  """
8044 
 
8045 
  thrift_spec = (
8046 
    (0, TType.I32, 'success', None, None, ), # 0
8047 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8048 
  )
8049 
 
8050 
  def __init__(self, success=None, ex=None,):
8051 
    self.success = success
8052 
    self.ex = ex
8053 
 
8054 
  def read(self, iprot):
8055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8057 
      return
8058 
    iprot.readStructBegin()
8059 
    while True:
8060 
      (fname, ftype, fid) = iprot.readFieldBegin()
8061 
      if ftype == TType.STOP:
8062 
        break
8063 
      if fid == 0:
8064 
        if ftype == TType.I32:
8065 
          self.success = iprot.readI32();
8066 
        else:
8067 
          iprot.skip(ftype)
8068 
      elif fid == 1:
8069 
        if ftype == TType.STRUCT:
8070 
          self.ex = TransactionServiceException()
8071 
          self.ex.read(iprot)
8072 
        else:
8073 
          iprot.skip(ftype)
8074 
      else:
8075 
        iprot.skip(ftype)
8076 
      iprot.readFieldEnd()
8077 
    iprot.readStructEnd()
8078 
 
8079 
  def write(self, oprot):
8080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8082 
      return
8083 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 8084 
    if self.success is not None:
94 ashish 8085 
      oprot.writeFieldBegin('success', TType.I32, 0)
8086 
      oprot.writeI32(self.success)
8087 
      oprot.writeFieldEnd()
3431 rajveer 8088 
    if self.ex is not None:
94 ashish 8089 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8090 
      self.ex.write(oprot)
8091 
      oprot.writeFieldEnd()
8092 
    oprot.writeFieldStop()
8093 
    oprot.writeStructEnd()
8094 
 
3431 rajveer 8095 
  def validate(self):
8096 
    return
8097 
 
8098 
 
94 ashish 8099 
  def __repr__(self):
8100 
    L = ['%s=%r' % (key, value)
8101 
      for key, value in self.__dict__.iteritems()]
8102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8103 
 
8104 
  def __eq__(self, other):
8105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8106 
 
8107 
  def __ne__(self, other):
8108 
    return not (self == other)
8109 
 
8110 
class changeTransactionStatus_args:
8111 
  """
8112 
  Attributes:
8113 
   - transactionId
8114 
   - status
8115 
   - description
5527 anupam.sin 8116 
   - pickUp
8117 
   - orderType
94 ashish 8118 
  """
8119 
 
8120 
  thrift_spec = (
8121 
    None, # 0
8122 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8123 
    (2, TType.I32, 'status', None, None, ), # 2
8124 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 8125 
    (4, TType.I64, 'pickUp', None, None, ), # 4
8126 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 8127 
  )
8128 
 
5527 anupam.sin 8129 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 8130 
    self.transactionId = transactionId
8131 
    self.status = status
8132 
    self.description = description
5527 anupam.sin 8133 
    self.pickUp = pickUp
8134 
    self.orderType = orderType
94 ashish 8135 
 
8136 
  def read(self, iprot):
8137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8139 
      return
8140 
    iprot.readStructBegin()
8141 
    while True:
8142 
      (fname, ftype, fid) = iprot.readFieldBegin()
8143 
      if ftype == TType.STOP:
8144 
        break
8145 
      if fid == 1:
8146 
        if ftype == TType.I64:
8147 
          self.transactionId = iprot.readI64();
8148 
        else:
8149 
          iprot.skip(ftype)
8150 
      elif fid == 2:
8151 
        if ftype == TType.I32:
8152 
          self.status = iprot.readI32();
8153 
        else:
8154 
          iprot.skip(ftype)
8155 
      elif fid == 3:
8156 
        if ftype == TType.STRING:
8157 
          self.description = iprot.readString();
8158 
        else:
8159 
          iprot.skip(ftype)
5387 rajveer 8160 
      elif fid == 4:
5527 anupam.sin 8161 
        if ftype == TType.I64:
8162 
          self.pickUp = iprot.readI64();
5387 rajveer 8163 
        else:
8164 
          iprot.skip(ftype)
5527 anupam.sin 8165 
      elif fid == 5:
8166 
        if ftype == TType.I32:
8167 
          self.orderType = iprot.readI32();
8168 
        else:
8169 
          iprot.skip(ftype)
94 ashish 8170 
      else:
8171 
        iprot.skip(ftype)
8172 
      iprot.readFieldEnd()
8173 
    iprot.readStructEnd()
8174 
 
8175 
  def write(self, oprot):
8176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8178 
      return
8179 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 8180 
    if self.transactionId is not None:
94 ashish 8181 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8182 
      oprot.writeI64(self.transactionId)
8183 
      oprot.writeFieldEnd()
3431 rajveer 8184 
    if self.status is not None:
94 ashish 8185 
      oprot.writeFieldBegin('status', TType.I32, 2)
8186 
      oprot.writeI32(self.status)
8187 
      oprot.writeFieldEnd()
3431 rajveer 8188 
    if self.description is not None:
94 ashish 8189 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8190 
      oprot.writeString(self.description)
8191 
      oprot.writeFieldEnd()
5527 anupam.sin 8192 
    if self.pickUp is not None:
8193 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
8194 
      oprot.writeI64(self.pickUp)
5387 rajveer 8195 
      oprot.writeFieldEnd()
5527 anupam.sin 8196 
    if self.orderType is not None:
8197 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
8198 
      oprot.writeI32(self.orderType)
8199 
      oprot.writeFieldEnd()
94 ashish 8200 
    oprot.writeFieldStop()
8201 
    oprot.writeStructEnd()
8202 
 
3431 rajveer 8203 
  def validate(self):
8204 
    return
8205 
 
8206 
 
94 ashish 8207 
  def __repr__(self):
8208 
    L = ['%s=%r' % (key, value)
8209 
      for key, value in self.__dict__.iteritems()]
8210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8211 
 
8212 
  def __eq__(self, other):
8213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8214 
 
8215 
  def __ne__(self, other):
8216 
    return not (self == other)
8217 
 
8218 
class changeTransactionStatus_result:
8219 
  """
8220 
  Attributes:
8221 
   - success
8222 
   - ex
8223 
  """
8224 
 
8225 
  thrift_spec = (
8226 
    (0, TType.BOOL, 'success', None, None, ), # 0
8227 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8228 
  )
8229 
 
8230 
  def __init__(self, success=None, ex=None,):
8231 
    self.success = success
8232 
    self.ex = ex
8233 
 
8234 
  def read(self, iprot):
8235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8237 
      return
8238 
    iprot.readStructBegin()
8239 
    while True:
8240 
      (fname, ftype, fid) = iprot.readFieldBegin()
8241 
      if ftype == TType.STOP:
8242 
        break
8243 
      if fid == 0:
8244 
        if ftype == TType.BOOL:
8245 
          self.success = iprot.readBool();
8246 
        else:
8247 
          iprot.skip(ftype)
8248 
      elif fid == 1:
8249 
        if ftype == TType.STRUCT:
8250 
          self.ex = TransactionServiceException()
8251 
          self.ex.read(iprot)
8252 
        else:
8253 
          iprot.skip(ftype)
8254 
      else:
8255 
        iprot.skip(ftype)
8256 
      iprot.readFieldEnd()
8257 
    iprot.readStructEnd()
8258 
 
8259 
  def write(self, oprot):
8260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8262 
      return
8263 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 8264 
    if self.success is not None:
94 ashish 8265 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8266 
      oprot.writeBool(self.success)
8267 
      oprot.writeFieldEnd()
3431 rajveer 8268 
    if self.ex is not None:
94 ashish 8269 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8270 
      self.ex.write(oprot)
8271 
      oprot.writeFieldEnd()
8272 
    oprot.writeFieldStop()
8273 
    oprot.writeStructEnd()
8274 
 
3431 rajveer 8275 
  def validate(self):
8276 
    return
8277 
 
8278 
 
94 ashish 8279 
  def __repr__(self):
8280 
    L = ['%s=%r' % (key, value)
8281 
      for key, value in self.__dict__.iteritems()]
8282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8283 
 
8284 
  def __eq__(self, other):
8285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8286 
 
8287 
  def __ne__(self, other):
8288 
    return not (self == other)
8289 
 
1398 varun.gupt 8290 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 8291 
  """
8292 
  Attributes:
8293 
   - transactionId
8294 
  """
8295 
 
8296 
  thrift_spec = (
8297 
    None, # 0
8298 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8299 
  )
8300 
 
8301 
  def __init__(self, transactionId=None,):
8302 
    self.transactionId = transactionId
8303 
 
8304 
  def read(self, iprot):
8305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8307 
      return
8308 
    iprot.readStructBegin()
8309 
    while True:
8310 
      (fname, ftype, fid) = iprot.readFieldBegin()
8311 
      if ftype == TType.STOP:
8312 
        break
8313 
      if fid == 1:
8314 
        if ftype == TType.I64:
8315 
          self.transactionId = iprot.readI64();
8316 
        else:
8317 
          iprot.skip(ftype)
8318 
      else:
8319 
        iprot.skip(ftype)
8320 
      iprot.readFieldEnd()
8321 
    iprot.readStructEnd()
8322 
 
8323 
  def write(self, oprot):
8324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8326 
      return
1398 varun.gupt 8327 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 8328 
    if self.transactionId is not None:
1382 varun.gupt 8329 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8330 
      oprot.writeI64(self.transactionId)
8331 
      oprot.writeFieldEnd()
8332 
    oprot.writeFieldStop()
8333 
    oprot.writeStructEnd()
8334 
 
3431 rajveer 8335 
  def validate(self):
8336 
    return
8337 
 
8338 
 
1382 varun.gupt 8339 
  def __repr__(self):
8340 
    L = ['%s=%r' % (key, value)
8341 
      for key, value in self.__dict__.iteritems()]
8342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8343 
 
8344 
  def __eq__(self, other):
8345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8346 
 
8347 
  def __ne__(self, other):
8348 
    return not (self == other)
8349 
 
1398 varun.gupt 8350 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 8351 
  """
8352 
  Attributes:
8353 
   - success
8354 
   - ex
8355 
  """
8356 
 
8357 
  thrift_spec = (
8358 
    (0, TType.BOOL, 'success', None, None, ), # 0
8359 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8360 
  )
8361 
 
8362 
  def __init__(self, success=None, ex=None,):
8363 
    self.success = success
8364 
    self.ex = ex
8365 
 
8366 
  def read(self, iprot):
8367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8369 
      return
8370 
    iprot.readStructBegin()
8371 
    while True:
8372 
      (fname, ftype, fid) = iprot.readFieldBegin()
8373 
      if ftype == TType.STOP:
8374 
        break
8375 
      if fid == 0:
8376 
        if ftype == TType.BOOL:
8377 
          self.success = iprot.readBool();
8378 
        else:
8379 
          iprot.skip(ftype)
8380 
      elif fid == 1:
8381 
        if ftype == TType.STRUCT:
8382 
          self.ex = TransactionServiceException()
8383 
          self.ex.read(iprot)
8384 
        else:
8385 
          iprot.skip(ftype)
8386 
      else:
8387 
        iprot.skip(ftype)
8388 
      iprot.readFieldEnd()
8389 
    iprot.readStructEnd()
8390 
 
8391 
  def write(self, oprot):
8392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8394 
      return
1398 varun.gupt 8395 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 8396 
    if self.success is not None:
1382 varun.gupt 8397 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8398 
      oprot.writeBool(self.success)
8399 
      oprot.writeFieldEnd()
3431 rajveer 8400 
    if self.ex is not None:
1382 varun.gupt 8401 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8402 
      self.ex.write(oprot)
8403 
      oprot.writeFieldEnd()
8404 
    oprot.writeFieldStop()
8405 
    oprot.writeStructEnd()
8406 
 
3431 rajveer 8407 
  def validate(self):
8408 
    return
8409 
 
8410 
 
1382 varun.gupt 8411 
  def __repr__(self):
8412 
    L = ['%s=%r' % (key, value)
8413 
      for key, value in self.__dict__.iteritems()]
8414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8415 
 
8416 
  def __eq__(self, other):
8417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8418 
 
8419 
  def __ne__(self, other):
8420 
    return not (self == other)
8421 
 
483 rajveer 8422 
class getAllOrders_args:
94 ashish 8423 
  """
8424 
  Attributes:
4801 anupam.sin 8425 
   - statuses
483 rajveer 8426 
   - from_date
8427 
   - to_date
8428 
   - warehouse_id
94 ashish 8429 
  """
8430 
 
8431 
  thrift_spec = (
8432 
    None, # 0
4801 anupam.sin 8433 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 8434 
    (2, TType.I64, 'from_date', None, None, ), # 2
8435 
    (3, TType.I64, 'to_date', None, None, ), # 3
8436 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 8437 
  )
8438 
 
4801 anupam.sin 8439 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
8440 
    self.statuses = statuses
483 rajveer 8441 
    self.from_date = from_date
8442 
    self.to_date = to_date
8443 
    self.warehouse_id = warehouse_id
94 ashish 8444 
 
8445 
  def read(self, iprot):
8446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8448 
      return
8449 
    iprot.readStructBegin()
8450 
    while True:
8451 
      (fname, ftype, fid) = iprot.readFieldBegin()
8452 
      if ftype == TType.STOP:
8453 
        break
8454 
      if fid == 1:
4801 anupam.sin 8455 
        if ftype == TType.LIST:
8456 
          self.statuses = []
5031 varun.gupt 8457 
          (_etype80, _size77) = iprot.readListBegin()
8458 
          for _i81 in xrange(_size77):
8459 
            _elem82 = iprot.readI32();
8460 
            self.statuses.append(_elem82)
4801 anupam.sin 8461 
          iprot.readListEnd()
94 ashish 8462 
        else:
8463 
          iprot.skip(ftype)
483 rajveer 8464 
      elif fid == 2:
8465 
        if ftype == TType.I64:
8466 
          self.from_date = iprot.readI64();
94 ashish 8467 
        else:
8468 
          iprot.skip(ftype)
483 rajveer 8469 
      elif fid == 3:
8470 
        if ftype == TType.I64:
8471 
          self.to_date = iprot.readI64();
94 ashish 8472 
        else:
8473 
          iprot.skip(ftype)
483 rajveer 8474 
      elif fid == 4:
94 ashish 8475 
        if ftype == TType.I64:
483 rajveer 8476 
          self.warehouse_id = iprot.readI64();
94 ashish 8477 
        else:
8478 
          iprot.skip(ftype)
8479 
      else:
8480 
        iprot.skip(ftype)
8481 
      iprot.readFieldEnd()
8482 
    iprot.readStructEnd()
8483 
 
8484 
  def write(self, oprot):
8485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8487 
      return
483 rajveer 8488 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 8489 
    if self.statuses is not None:
8490 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8491 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8492 
      for iter83 in self.statuses:
8493 
        oprot.writeI32(iter83)
4801 anupam.sin 8494 
      oprot.writeListEnd()
94 ashish 8495 
      oprot.writeFieldEnd()
3431 rajveer 8496 
    if self.from_date is not None:
483 rajveer 8497 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8498 
      oprot.writeI64(self.from_date)
94 ashish 8499 
      oprot.writeFieldEnd()
3431 rajveer 8500 
    if self.to_date is not None:
483 rajveer 8501 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8502 
      oprot.writeI64(self.to_date)
94 ashish 8503 
      oprot.writeFieldEnd()
3431 rajveer 8504 
    if self.warehouse_id is not None:
483 rajveer 8505 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8506 
      oprot.writeI64(self.warehouse_id)
94 ashish 8507 
      oprot.writeFieldEnd()
8508 
    oprot.writeFieldStop()
8509 
    oprot.writeStructEnd()
8510 
 
3431 rajveer 8511 
  def validate(self):
8512 
    return
8513 
 
8514 
 
94 ashish 8515 
  def __repr__(self):
8516 
    L = ['%s=%r' % (key, value)
8517 
      for key, value in self.__dict__.iteritems()]
8518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8519 
 
8520 
  def __eq__(self, other):
8521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8522 
 
8523 
  def __ne__(self, other):
8524 
    return not (self == other)
8525 
 
483 rajveer 8526 
class getAllOrders_result:
94 ashish 8527 
  """
8528 
  Attributes:
8529 
   - success
8530 
   - ex
8531 
  """
8532 
 
8533 
  thrift_spec = (
483 rajveer 8534 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 8535 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8536 
  )
8537 
 
8538 
  def __init__(self, success=None, ex=None,):
8539 
    self.success = success
8540 
    self.ex = ex
8541 
 
8542 
  def read(self, iprot):
8543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8545 
      return
8546 
    iprot.readStructBegin()
8547 
    while True:
8548 
      (fname, ftype, fid) = iprot.readFieldBegin()
8549 
      if ftype == TType.STOP:
8550 
        break
8551 
      if fid == 0:
483 rajveer 8552 
        if ftype == TType.LIST:
8553 
          self.success = []
5031 varun.gupt 8554 
          (_etype87, _size84) = iprot.readListBegin()
8555 
          for _i88 in xrange(_size84):
8556 
            _elem89 = Order()
8557 
            _elem89.read(iprot)
8558 
            self.success.append(_elem89)
483 rajveer 8559 
          iprot.readListEnd()
94 ashish 8560 
        else:
8561 
          iprot.skip(ftype)
8562 
      elif fid == 1:
8563 
        if ftype == TType.STRUCT:
8564 
          self.ex = TransactionServiceException()
8565 
          self.ex.read(iprot)
8566 
        else:
8567 
          iprot.skip(ftype)
8568 
      else:
8569 
        iprot.skip(ftype)
8570 
      iprot.readFieldEnd()
8571 
    iprot.readStructEnd()
8572 
 
8573 
  def write(self, oprot):
8574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8576 
      return
483 rajveer 8577 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 8578 
    if self.success is not None:
483 rajveer 8579 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8580 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8581 
      for iter90 in self.success:
8582 
        iter90.write(oprot)
483 rajveer 8583 
      oprot.writeListEnd()
94 ashish 8584 
      oprot.writeFieldEnd()
3431 rajveer 8585 
    if self.ex is not None:
94 ashish 8586 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8587 
      self.ex.write(oprot)
8588 
      oprot.writeFieldEnd()
8589 
    oprot.writeFieldStop()
8590 
    oprot.writeStructEnd()
8591 
 
3431 rajveer 8592 
  def validate(self):
8593 
    return
8594 
 
8595 
 
94 ashish 8596 
  def __repr__(self):
8597 
    L = ['%s=%r' % (key, value)
8598 
      for key, value in self.__dict__.iteritems()]
8599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8600 
 
8601 
  def __eq__(self, other):
8602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8603 
 
8604 
  def __ne__(self, other):
8605 
    return not (self == other)
8606 
 
4133 chandransh 8607 
class getOrdersInBatch_args:
8608 
  """
8609 
  Attributes:
8610 
   - statuses
8611 
   - offset
8612 
   - limit
8613 
   - warehouse_id
8614 
  """
8615 
 
8616 
  thrift_spec = (
8617 
    None, # 0
8618 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8619 
    (2, TType.I64, 'offset', None, None, ), # 2
8620 
    (3, TType.I64, 'limit', None, None, ), # 3
8621 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8622 
  )
8623 
 
8624 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
8625 
    self.statuses = statuses
8626 
    self.offset = offset
8627 
    self.limit = limit
8628 
    self.warehouse_id = warehouse_id
8629 
 
8630 
  def read(self, iprot):
8631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8633 
      return
8634 
    iprot.readStructBegin()
8635 
    while True:
8636 
      (fname, ftype, fid) = iprot.readFieldBegin()
8637 
      if ftype == TType.STOP:
8638 
        break
8639 
      if fid == 1:
8640 
        if ftype == TType.LIST:
8641 
          self.statuses = []
5031 varun.gupt 8642 
          (_etype94, _size91) = iprot.readListBegin()
8643 
          for _i95 in xrange(_size91):
8644 
            _elem96 = iprot.readI32();
8645 
            self.statuses.append(_elem96)
4133 chandransh 8646 
          iprot.readListEnd()
8647 
        else:
8648 
          iprot.skip(ftype)
8649 
      elif fid == 2:
8650 
        if ftype == TType.I64:
8651 
          self.offset = iprot.readI64();
8652 
        else:
8653 
          iprot.skip(ftype)
8654 
      elif fid == 3:
8655 
        if ftype == TType.I64:
8656 
          self.limit = iprot.readI64();
8657 
        else:
8658 
          iprot.skip(ftype)
8659 
      elif fid == 4:
8660 
        if ftype == TType.I64:
8661 
          self.warehouse_id = iprot.readI64();
8662 
        else:
8663 
          iprot.skip(ftype)
8664 
      else:
8665 
        iprot.skip(ftype)
8666 
      iprot.readFieldEnd()
8667 
    iprot.readStructEnd()
8668 
 
8669 
  def write(self, oprot):
8670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8672 
      return
8673 
    oprot.writeStructBegin('getOrdersInBatch_args')
8674 
    if self.statuses is not None:
8675 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8676 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8677 
      for iter97 in self.statuses:
8678 
        oprot.writeI32(iter97)
4133 chandransh 8679 
      oprot.writeListEnd()
8680 
      oprot.writeFieldEnd()
8681 
    if self.offset is not None:
8682 
      oprot.writeFieldBegin('offset', TType.I64, 2)
8683 
      oprot.writeI64(self.offset)
8684 
      oprot.writeFieldEnd()
8685 
    if self.limit is not None:
8686 
      oprot.writeFieldBegin('limit', TType.I64, 3)
8687 
      oprot.writeI64(self.limit)
8688 
      oprot.writeFieldEnd()
8689 
    if self.warehouse_id is not None:
8690 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
8691 
      oprot.writeI64(self.warehouse_id)
8692 
      oprot.writeFieldEnd()
8693 
    oprot.writeFieldStop()
8694 
    oprot.writeStructEnd()
8695 
 
8696 
  def validate(self):
8697 
    return
8698 
 
8699 
 
8700 
  def __repr__(self):
8701 
    L = ['%s=%r' % (key, value)
8702 
      for key, value in self.__dict__.iteritems()]
8703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8704 
 
8705 
  def __eq__(self, other):
8706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8707 
 
8708 
  def __ne__(self, other):
8709 
    return not (self == other)
8710 
 
8711 
class getOrdersInBatch_result:
8712 
  """
8713 
  Attributes:
8714 
   - success
8715 
   - ex
8716 
  """
8717 
 
8718 
  thrift_spec = (
8719 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8720 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8721 
  )
8722 
 
8723 
  def __init__(self, success=None, ex=None,):
8724 
    self.success = success
8725 
    self.ex = ex
8726 
 
8727 
  def read(self, iprot):
8728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8730 
      return
8731 
    iprot.readStructBegin()
8732 
    while True:
8733 
      (fname, ftype, fid) = iprot.readFieldBegin()
8734 
      if ftype == TType.STOP:
8735 
        break
8736 
      if fid == 0:
8737 
        if ftype == TType.LIST:
8738 
          self.success = []
5031 varun.gupt 8739 
          (_etype101, _size98) = iprot.readListBegin()
8740 
          for _i102 in xrange(_size98):
8741 
            _elem103 = Order()
8742 
            _elem103.read(iprot)
8743 
            self.success.append(_elem103)
4133 chandransh 8744 
          iprot.readListEnd()
8745 
        else:
8746 
          iprot.skip(ftype)
8747 
      elif fid == 1:
8748 
        if ftype == TType.STRUCT:
8749 
          self.ex = TransactionServiceException()
8750 
          self.ex.read(iprot)
8751 
        else:
8752 
          iprot.skip(ftype)
8753 
      else:
8754 
        iprot.skip(ftype)
8755 
      iprot.readFieldEnd()
8756 
    iprot.readStructEnd()
8757 
 
8758 
  def write(self, oprot):
8759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8761 
      return
8762 
    oprot.writeStructBegin('getOrdersInBatch_result')
8763 
    if self.success is not None:
8764 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8765 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 8766 
      for iter104 in self.success:
8767 
        iter104.write(oprot)
4133 chandransh 8768 
      oprot.writeListEnd()
8769 
      oprot.writeFieldEnd()
8770 
    if self.ex is not None:
8771 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8772 
      self.ex.write(oprot)
8773 
      oprot.writeFieldEnd()
8774 
    oprot.writeFieldStop()
8775 
    oprot.writeStructEnd()
8776 
 
8777 
  def validate(self):
8778 
    return
8779 
 
8780 
 
8781 
  def __repr__(self):
8782 
    L = ['%s=%r' % (key, value)
8783 
      for key, value in self.__dict__.iteritems()]
8784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8785 
 
8786 
  def __eq__(self, other):
8787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8788 
 
8789 
  def __ne__(self, other):
8790 
    return not (self == other)
8791 
 
8792 
class getOrderCount_args:
8793 
  """
8794 
  Attributes:
8795 
   - statuses
8796 
   - warehouseId
8797 
  """
8798 
 
8799 
  thrift_spec = (
8800 
    None, # 0
8801 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
8802 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
8803 
  )
8804 
 
8805 
  def __init__(self, statuses=None, warehouseId=None,):
8806 
    self.statuses = statuses
8807 
    self.warehouseId = warehouseId
8808 
 
8809 
  def read(self, iprot):
8810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8812 
      return
8813 
    iprot.readStructBegin()
8814 
    while True:
8815 
      (fname, ftype, fid) = iprot.readFieldBegin()
8816 
      if ftype == TType.STOP:
8817 
        break
8818 
      if fid == 1:
8819 
        if ftype == TType.LIST:
8820 
          self.statuses = []
5031 varun.gupt 8821 
          (_etype108, _size105) = iprot.readListBegin()
8822 
          for _i109 in xrange(_size105):
8823 
            _elem110 = iprot.readI32();
8824 
            self.statuses.append(_elem110)
4133 chandransh 8825 
          iprot.readListEnd()
8826 
        else:
8827 
          iprot.skip(ftype)
8828 
      elif fid == 2:
8829 
        if ftype == TType.I64:
8830 
          self.warehouseId = iprot.readI64();
8831 
        else:
8832 
          iprot.skip(ftype)
8833 
      else:
8834 
        iprot.skip(ftype)
8835 
      iprot.readFieldEnd()
8836 
    iprot.readStructEnd()
8837 
 
8838 
  def write(self, oprot):
8839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8841 
      return
8842 
    oprot.writeStructBegin('getOrderCount_args')
8843 
    if self.statuses is not None:
8844 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
8845 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 8846 
      for iter111 in self.statuses:
8847 
        oprot.writeI32(iter111)
4133 chandransh 8848 
      oprot.writeListEnd()
8849 
      oprot.writeFieldEnd()
8850 
    if self.warehouseId is not None:
8851 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
8852 
      oprot.writeI64(self.warehouseId)
8853 
      oprot.writeFieldEnd()
8854 
    oprot.writeFieldStop()
8855 
    oprot.writeStructEnd()
8856 
 
8857 
  def validate(self):
8858 
    return
8859 
 
8860 
 
8861 
  def __repr__(self):
8862 
    L = ['%s=%r' % (key, value)
8863 
      for key, value in self.__dict__.iteritems()]
8864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8865 
 
8866 
  def __eq__(self, other):
8867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8868 
 
8869 
  def __ne__(self, other):
8870 
    return not (self == other)
8871 
 
8872 
class getOrderCount_result:
8873 
  """
8874 
  Attributes:
8875 
   - success
8876 
   - ex
8877 
  """
8878 
 
8879 
  thrift_spec = (
8880 
    (0, TType.I32, 'success', None, None, ), # 0
8881 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8882 
  )
8883 
 
8884 
  def __init__(self, success=None, ex=None,):
8885 
    self.success = success
8886 
    self.ex = ex
8887 
 
8888 
  def read(self, iprot):
8889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8891 
      return
8892 
    iprot.readStructBegin()
8893 
    while True:
8894 
      (fname, ftype, fid) = iprot.readFieldBegin()
8895 
      if ftype == TType.STOP:
8896 
        break
8897 
      if fid == 0:
8898 
        if ftype == TType.I32:
8899 
          self.success = iprot.readI32();
8900 
        else:
8901 
          iprot.skip(ftype)
8902 
      elif fid == 1:
8903 
        if ftype == TType.STRUCT:
8904 
          self.ex = TransactionServiceException()
8905 
          self.ex.read(iprot)
8906 
        else:
8907 
          iprot.skip(ftype)
8908 
      else:
8909 
        iprot.skip(ftype)
8910 
      iprot.readFieldEnd()
8911 
    iprot.readStructEnd()
8912 
 
8913 
  def write(self, oprot):
8914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8916 
      return
8917 
    oprot.writeStructBegin('getOrderCount_result')
8918 
    if self.success is not None:
8919 
      oprot.writeFieldBegin('success', TType.I32, 0)
8920 
      oprot.writeI32(self.success)
8921 
      oprot.writeFieldEnd()
8922 
    if self.ex is not None:
8923 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8924 
      self.ex.write(oprot)
8925 
      oprot.writeFieldEnd()
8926 
    oprot.writeFieldStop()
8927 
    oprot.writeStructEnd()
8928 
 
8929 
  def validate(self):
8930 
    return
8931 
 
8932 
 
8933 
  def __repr__(self):
8934 
    L = ['%s=%r' % (key, value)
8935 
      for key, value in self.__dict__.iteritems()]
8936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8937 
 
8938 
  def __eq__(self, other):
8939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8940 
 
8941 
  def __ne__(self, other):
8942 
    return not (self == other)
8943 
 
999 varun.gupt 8944 
class getOrdersByBillingDate_args:
8945 
  """
8946 
  Attributes:
8947 
   - status
8948 
   - start_billing_date
8949 
   - end_billing_date
8950 
   - warehouse_id
8951 
  """
8952 
 
8953 
  thrift_spec = (
8954 
    None, # 0
8955 
    (1, TType.I32, 'status', None, None, ), # 1
8956 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
8957 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
8958 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
8959 
  )
8960 
 
8961 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
8962 
    self.status = status
8963 
    self.start_billing_date = start_billing_date
8964 
    self.end_billing_date = end_billing_date
8965 
    self.warehouse_id = warehouse_id
8966 
 
8967 
  def read(self, iprot):
8968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8970 
      return
8971 
    iprot.readStructBegin()
8972 
    while True:
8973 
      (fname, ftype, fid) = iprot.readFieldBegin()
8974 
      if ftype == TType.STOP:
8975 
        break
8976 
      if fid == 1:
8977 
        if ftype == TType.I32:
8978 
          self.status = iprot.readI32();
8979 
        else:
8980 
          iprot.skip(ftype)
8981 
      elif fid == 2:
8982 
        if ftype == TType.I64:
8983 
          self.start_billing_date = iprot.readI64();
8984 
        else:
8985 
          iprot.skip(ftype)
8986 
      elif fid == 3:
8987 
        if ftype == TType.I64:
8988 
          self.end_billing_date = iprot.readI64();
8989 
        else:
8990 
          iprot.skip(ftype)
8991 
      elif fid == 4:
8992 
        if ftype == TType.I64:
8993 
          self.warehouse_id = iprot.readI64();
8994 
        else:
8995 
          iprot.skip(ftype)
8996 
      else:
8997 
        iprot.skip(ftype)
8998 
      iprot.readFieldEnd()
8999 
    iprot.readStructEnd()
9000 
 
9001 
  def write(self, oprot):
9002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9004 
      return
9005 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 9006 
    if self.status is not None:
999 varun.gupt 9007 
      oprot.writeFieldBegin('status', TType.I32, 1)
9008 
      oprot.writeI32(self.status)
9009 
      oprot.writeFieldEnd()
3431 rajveer 9010 
    if self.start_billing_date is not None:
999 varun.gupt 9011 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
9012 
      oprot.writeI64(self.start_billing_date)
9013 
      oprot.writeFieldEnd()
3431 rajveer 9014 
    if self.end_billing_date is not None:
999 varun.gupt 9015 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
9016 
      oprot.writeI64(self.end_billing_date)
9017 
      oprot.writeFieldEnd()
3431 rajveer 9018 
    if self.warehouse_id is not None:
999 varun.gupt 9019 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9020 
      oprot.writeI64(self.warehouse_id)
9021 
      oprot.writeFieldEnd()
9022 
    oprot.writeFieldStop()
9023 
    oprot.writeStructEnd()
9024 
 
3431 rajveer 9025 
  def validate(self):
9026 
    return
9027 
 
9028 
 
999 varun.gupt 9029 
  def __repr__(self):
9030 
    L = ['%s=%r' % (key, value)
9031 
      for key, value in self.__dict__.iteritems()]
9032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9033 
 
9034 
  def __eq__(self, other):
9035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9036 
 
9037 
  def __ne__(self, other):
9038 
    return not (self == other)
9039 
 
9040 
class getOrdersByBillingDate_result:
9041 
  """
9042 
  Attributes:
9043 
   - success
9044 
   - ex
9045 
  """
9046 
 
9047 
  thrift_spec = (
9048 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9049 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9050 
  )
9051 
 
9052 
  def __init__(self, success=None, ex=None,):
9053 
    self.success = success
9054 
    self.ex = ex
9055 
 
9056 
  def read(self, iprot):
9057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9059 
      return
9060 
    iprot.readStructBegin()
9061 
    while True:
9062 
      (fname, ftype, fid) = iprot.readFieldBegin()
9063 
      if ftype == TType.STOP:
9064 
        break
9065 
      if fid == 0:
9066 
        if ftype == TType.LIST:
9067 
          self.success = []
5031 varun.gupt 9068 
          (_etype115, _size112) = iprot.readListBegin()
9069 
          for _i116 in xrange(_size112):
9070 
            _elem117 = Order()
9071 
            _elem117.read(iprot)
9072 
            self.success.append(_elem117)
999 varun.gupt 9073 
          iprot.readListEnd()
9074 
        else:
9075 
          iprot.skip(ftype)
9076 
      elif fid == 1:
9077 
        if ftype == TType.STRUCT:
9078 
          self.ex = TransactionServiceException()
9079 
          self.ex.read(iprot)
9080 
        else:
9081 
          iprot.skip(ftype)
9082 
      else:
9083 
        iprot.skip(ftype)
9084 
      iprot.readFieldEnd()
9085 
    iprot.readStructEnd()
9086 
 
9087 
  def write(self, oprot):
9088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9090 
      return
9091 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 9092 
    if self.success is not None:
999 varun.gupt 9093 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9094 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9095 
      for iter118 in self.success:
9096 
        iter118.write(oprot)
999 varun.gupt 9097 
      oprot.writeListEnd()
9098 
      oprot.writeFieldEnd()
3431 rajveer 9099 
    if self.ex is not None:
999 varun.gupt 9100 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9101 
      self.ex.write(oprot)
9102 
      oprot.writeFieldEnd()
9103 
    oprot.writeFieldStop()
9104 
    oprot.writeStructEnd()
9105 
 
3431 rajveer 9106 
  def validate(self):
9107 
    return
9108 
 
9109 
 
999 varun.gupt 9110 
  def __repr__(self):
9111 
    L = ['%s=%r' % (key, value)
9112 
      for key, value in self.__dict__.iteritems()]
9113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9114 
 
9115 
  def __eq__(self, other):
9116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9117 
 
9118 
  def __ne__(self, other):
9119 
    return not (self == other)
9120 
 
3427 chandransh 9121 
class getOrdersByShippingDate_args:
9122 
  """
9123 
  Attributes:
9124 
   - fromShippingDate
9125 
   - toShippingDate
9126 
   - providerId
9127 
   - warehouseId
3451 chandransh 9128 
   - cod
3427 chandransh 9129 
  """
9130 
 
9131 
  thrift_spec = (
9132 
    None, # 0
9133 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
9134 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
9135 
    (3, TType.I64, 'providerId', None, None, ), # 3
9136 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 9137 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 9138 
  )
9139 
 
3451 chandransh 9140 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 9141 
    self.fromShippingDate = fromShippingDate
9142 
    self.toShippingDate = toShippingDate
9143 
    self.providerId = providerId
9144 
    self.warehouseId = warehouseId
3451 chandransh 9145 
    self.cod = cod
3427 chandransh 9146 
 
9147 
  def read(self, iprot):
9148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9150 
      return
9151 
    iprot.readStructBegin()
9152 
    while True:
9153 
      (fname, ftype, fid) = iprot.readFieldBegin()
9154 
      if ftype == TType.STOP:
9155 
        break
9156 
      if fid == 1:
9157 
        if ftype == TType.I64:
9158 
          self.fromShippingDate = iprot.readI64();
9159 
        else:
9160 
          iprot.skip(ftype)
9161 
      elif fid == 2:
9162 
        if ftype == TType.I64:
9163 
          self.toShippingDate = iprot.readI64();
9164 
        else:
9165 
          iprot.skip(ftype)
9166 
      elif fid == 3:
9167 
        if ftype == TType.I64:
9168 
          self.providerId = iprot.readI64();
9169 
        else:
9170 
          iprot.skip(ftype)
9171 
      elif fid == 4:
9172 
        if ftype == TType.I64:
9173 
          self.warehouseId = iprot.readI64();
9174 
        else:
9175 
          iprot.skip(ftype)
3451 chandransh 9176 
      elif fid == 5:
9177 
        if ftype == TType.BOOL:
9178 
          self.cod = iprot.readBool();
9179 
        else:
9180 
          iprot.skip(ftype)
3427 chandransh 9181 
      else:
9182 
        iprot.skip(ftype)
9183 
      iprot.readFieldEnd()
9184 
    iprot.readStructEnd()
9185 
 
9186 
  def write(self, oprot):
9187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9189 
      return
9190 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 9191 
    if self.fromShippingDate is not None:
3427 chandransh 9192 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
9193 
      oprot.writeI64(self.fromShippingDate)
9194 
      oprot.writeFieldEnd()
3431 rajveer 9195 
    if self.toShippingDate is not None:
3427 chandransh 9196 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
9197 
      oprot.writeI64(self.toShippingDate)
9198 
      oprot.writeFieldEnd()
3431 rajveer 9199 
    if self.providerId is not None:
3427 chandransh 9200 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
9201 
      oprot.writeI64(self.providerId)
9202 
      oprot.writeFieldEnd()
3431 rajveer 9203 
    if self.warehouseId is not None:
3427 chandransh 9204 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
9205 
      oprot.writeI64(self.warehouseId)
9206 
      oprot.writeFieldEnd()
3451 chandransh 9207 
    if self.cod is not None:
9208 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
9209 
      oprot.writeBool(self.cod)
9210 
      oprot.writeFieldEnd()
3427 chandransh 9211 
    oprot.writeFieldStop()
9212 
    oprot.writeStructEnd()
9213 
 
3431 rajveer 9214 
  def validate(self):
9215 
    return
9216 
 
9217 
 
3427 chandransh 9218 
  def __repr__(self):
9219 
    L = ['%s=%r' % (key, value)
9220 
      for key, value in self.__dict__.iteritems()]
9221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9222 
 
9223 
  def __eq__(self, other):
9224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9225 
 
9226 
  def __ne__(self, other):
9227 
    return not (self == other)
9228 
 
9229 
class getOrdersByShippingDate_result:
9230 
  """
9231 
  Attributes:
9232 
   - success
9233 
   - ex
9234 
  """
9235 
 
9236 
  thrift_spec = (
9237 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9238 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9239 
  )
9240 
 
9241 
  def __init__(self, success=None, ex=None,):
9242 
    self.success = success
9243 
    self.ex = ex
9244 
 
9245 
  def read(self, iprot):
9246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9248 
      return
9249 
    iprot.readStructBegin()
9250 
    while True:
9251 
      (fname, ftype, fid) = iprot.readFieldBegin()
9252 
      if ftype == TType.STOP:
9253 
        break
9254 
      if fid == 0:
9255 
        if ftype == TType.LIST:
9256 
          self.success = []
5031 varun.gupt 9257 
          (_etype122, _size119) = iprot.readListBegin()
9258 
          for _i123 in xrange(_size119):
9259 
            _elem124 = Order()
9260 
            _elem124.read(iprot)
9261 
            self.success.append(_elem124)
3427 chandransh 9262 
          iprot.readListEnd()
9263 
        else:
9264 
          iprot.skip(ftype)
9265 
      elif fid == 1:
9266 
        if ftype == TType.STRUCT:
9267 
          self.ex = TransactionServiceException()
9268 
          self.ex.read(iprot)
9269 
        else:
9270 
          iprot.skip(ftype)
9271 
      else:
9272 
        iprot.skip(ftype)
9273 
      iprot.readFieldEnd()
9274 
    iprot.readStructEnd()
9275 
 
9276 
  def write(self, oprot):
9277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9279 
      return
9280 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 9281 
    if self.success is not None:
3427 chandransh 9282 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9283 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9284 
      for iter125 in self.success:
9285 
        iter125.write(oprot)
3427 chandransh 9286 
      oprot.writeListEnd()
9287 
      oprot.writeFieldEnd()
3431 rajveer 9288 
    if self.ex is not None:
3427 chandransh 9289 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9290 
      self.ex.write(oprot)
9291 
      oprot.writeFieldEnd()
9292 
    oprot.writeFieldStop()
9293 
    oprot.writeStructEnd()
9294 
 
3431 rajveer 9295 
  def validate(self):
9296 
    return
9297 
 
9298 
 
3427 chandransh 9299 
  def __repr__(self):
9300 
    L = ['%s=%r' % (key, value)
9301 
      for key, value in self.__dict__.iteritems()]
9302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9303 
 
9304 
  def __eq__(self, other):
9305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9306 
 
9307 
  def __ne__(self, other):
9308 
    return not (self == other)
9309 
 
1382 varun.gupt 9310 
class getReturnableOrdersForCustomer_args:
9311 
  """
9312 
  Attributes:
9313 
   - customer_id
9314 
   - limit
9315 
  """
9316 
 
9317 
  thrift_spec = (
9318 
    None, # 0
9319 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9320 
    (2, TType.I64, 'limit', None, None, ), # 2
9321 
  )
9322 
 
9323 
  def __init__(self, customer_id=None, limit=None,):
9324 
    self.customer_id = customer_id
9325 
    self.limit = limit
9326 
 
9327 
  def read(self, iprot):
9328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9330 
      return
9331 
    iprot.readStructBegin()
9332 
    while True:
9333 
      (fname, ftype, fid) = iprot.readFieldBegin()
9334 
      if ftype == TType.STOP:
9335 
        break
9336 
      if fid == 1:
9337 
        if ftype == TType.I64:
9338 
          self.customer_id = iprot.readI64();
9339 
        else:
9340 
          iprot.skip(ftype)
9341 
      elif fid == 2:
9342 
        if ftype == TType.I64:
9343 
          self.limit = iprot.readI64();
9344 
        else:
9345 
          iprot.skip(ftype)
9346 
      else:
9347 
        iprot.skip(ftype)
9348 
      iprot.readFieldEnd()
9349 
    iprot.readStructEnd()
9350 
 
9351 
  def write(self, oprot):
9352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9354 
      return
9355 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 9356 
    if self.customer_id is not None:
1382 varun.gupt 9357 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9358 
      oprot.writeI64(self.customer_id)
9359 
      oprot.writeFieldEnd()
3431 rajveer 9360 
    if self.limit is not None:
1382 varun.gupt 9361 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9362 
      oprot.writeI64(self.limit)
9363 
      oprot.writeFieldEnd()
9364 
    oprot.writeFieldStop()
9365 
    oprot.writeStructEnd()
9366 
 
3431 rajveer 9367 
  def validate(self):
9368 
    return
9369 
 
9370 
 
1382 varun.gupt 9371 
  def __repr__(self):
9372 
    L = ['%s=%r' % (key, value)
9373 
      for key, value in self.__dict__.iteritems()]
9374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9375 
 
9376 
  def __eq__(self, other):
9377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9378 
 
9379 
  def __ne__(self, other):
9380 
    return not (self == other)
9381 
 
9382 
class getReturnableOrdersForCustomer_result:
9383 
  """
9384 
  Attributes:
9385 
   - success
9386 
   - ex
9387 
  """
9388 
 
9389 
  thrift_spec = (
9390 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9391 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9392 
  )
9393 
 
9394 
  def __init__(self, success=None, ex=None,):
9395 
    self.success = success
9396 
    self.ex = ex
9397 
 
9398 
  def read(self, iprot):
9399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9401 
      return
9402 
    iprot.readStructBegin()
9403 
    while True:
9404 
      (fname, ftype, fid) = iprot.readFieldBegin()
9405 
      if ftype == TType.STOP:
9406 
        break
9407 
      if fid == 0:
9408 
        if ftype == TType.LIST:
9409 
          self.success = []
5031 varun.gupt 9410 
          (_etype129, _size126) = iprot.readListBegin()
9411 
          for _i130 in xrange(_size126):
9412 
            _elem131 = iprot.readI64();
9413 
            self.success.append(_elem131)
1382 varun.gupt 9414 
          iprot.readListEnd()
9415 
        else:
9416 
          iprot.skip(ftype)
9417 
      elif fid == 1:
9418 
        if ftype == TType.STRUCT:
9419 
          self.ex = TransactionServiceException()
9420 
          self.ex.read(iprot)
9421 
        else:
9422 
          iprot.skip(ftype)
9423 
      else:
9424 
        iprot.skip(ftype)
9425 
      iprot.readFieldEnd()
9426 
    iprot.readStructEnd()
9427 
 
9428 
  def write(self, oprot):
9429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9431 
      return
9432 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 9433 
    if self.success is not None:
1382 varun.gupt 9434 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9435 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 9436 
      for iter132 in self.success:
9437 
        oprot.writeI64(iter132)
1382 varun.gupt 9438 
      oprot.writeListEnd()
9439 
      oprot.writeFieldEnd()
3431 rajveer 9440 
    if self.ex is not None:
1382 varun.gupt 9441 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9442 
      self.ex.write(oprot)
9443 
      oprot.writeFieldEnd()
9444 
    oprot.writeFieldStop()
9445 
    oprot.writeStructEnd()
9446 
 
3431 rajveer 9447 
  def validate(self):
9448 
    return
9449 
 
9450 
 
1382 varun.gupt 9451 
  def __repr__(self):
9452 
    L = ['%s=%r' % (key, value)
9453 
      for key, value in self.__dict__.iteritems()]
9454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9455 
 
9456 
  def __eq__(self, other):
9457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9458 
 
9459 
  def __ne__(self, other):
9460 
    return not (self == other)
9461 
 
9462 
class getCancellableOrdersForCustomer_args:
9463 
  """
9464 
  Attributes:
9465 
   - customer_id
9466 
   - limit
9467 
  """
9468 
 
9469 
  thrift_spec = (
9470 
    None, # 0
9471 
    (1, TType.I64, 'customer_id', None, None, ), # 1
9472 
    (2, TType.I64, 'limit', None, None, ), # 2
9473 
  )
9474 
 
9475 
  def __init__(self, customer_id=None, limit=None,):
9476 
    self.customer_id = customer_id
9477 
    self.limit = limit
9478 
 
9479 
  def read(self, iprot):
9480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9482 
      return
9483 
    iprot.readStructBegin()
9484 
    while True:
9485 
      (fname, ftype, fid) = iprot.readFieldBegin()
9486 
      if ftype == TType.STOP:
9487 
        break
9488 
      if fid == 1:
9489 
        if ftype == TType.I64:
9490 
          self.customer_id = iprot.readI64();
9491 
        else:
9492 
          iprot.skip(ftype)
9493 
      elif fid == 2:
9494 
        if ftype == TType.I64:
9495 
          self.limit = iprot.readI64();
9496 
        else:
9497 
          iprot.skip(ftype)
9498 
      else:
9499 
        iprot.skip(ftype)
9500 
      iprot.readFieldEnd()
9501 
    iprot.readStructEnd()
9502 
 
9503 
  def write(self, oprot):
9504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9506 
      return
9507 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 9508 
    if self.customer_id is not None:
1382 varun.gupt 9509 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
9510 
      oprot.writeI64(self.customer_id)
9511 
      oprot.writeFieldEnd()
3431 rajveer 9512 
    if self.limit is not None:
1382 varun.gupt 9513 
      oprot.writeFieldBegin('limit', TType.I64, 2)
9514 
      oprot.writeI64(self.limit)
9515 
      oprot.writeFieldEnd()
9516 
    oprot.writeFieldStop()
9517 
    oprot.writeStructEnd()
9518 
 
3431 rajveer 9519 
  def validate(self):
9520 
    return
9521 
 
9522 
 
1382 varun.gupt 9523 
  def __repr__(self):
9524 
    L = ['%s=%r' % (key, value)
9525 
      for key, value in self.__dict__.iteritems()]
9526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9527 
 
9528 
  def __eq__(self, other):
9529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9530 
 
9531 
  def __ne__(self, other):
9532 
    return not (self == other)
9533 
 
9534 
class getCancellableOrdersForCustomer_result:
9535 
  """
9536 
  Attributes:
9537 
   - success
9538 
   - ex
9539 
  """
9540 
 
9541 
  thrift_spec = (
9542 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9543 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9544 
  )
9545 
 
9546 
  def __init__(self, success=None, ex=None,):
9547 
    self.success = success
9548 
    self.ex = ex
9549 
 
9550 
  def read(self, iprot):
9551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9553 
      return
9554 
    iprot.readStructBegin()
9555 
    while True:
9556 
      (fname, ftype, fid) = iprot.readFieldBegin()
9557 
      if ftype == TType.STOP:
9558 
        break
9559 
      if fid == 0:
9560 
        if ftype == TType.LIST:
9561 
          self.success = []
5031 varun.gupt 9562 
          (_etype136, _size133) = iprot.readListBegin()
9563 
          for _i137 in xrange(_size133):
9564 
            _elem138 = iprot.readI64();
9565 
            self.success.append(_elem138)
1382 varun.gupt 9566 
          iprot.readListEnd()
9567 
        else:
9568 
          iprot.skip(ftype)
9569 
      elif fid == 1:
9570 
        if ftype == TType.STRUCT:
9571 
          self.ex = TransactionServiceException()
9572 
          self.ex.read(iprot)
9573 
        else:
9574 
          iprot.skip(ftype)
9575 
      else:
9576 
        iprot.skip(ftype)
9577 
      iprot.readFieldEnd()
9578 
    iprot.readStructEnd()
9579 
 
9580 
  def write(self, oprot):
9581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9583 
      return
9584 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 9585 
    if self.success is not None:
1382 varun.gupt 9586 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9587 
      oprot.writeListBegin(TType.I64, len(self.success))
5031 varun.gupt 9588 
      for iter139 in self.success:
9589 
        oprot.writeI64(iter139)
1382 varun.gupt 9590 
      oprot.writeListEnd()
9591 
      oprot.writeFieldEnd()
3431 rajveer 9592 
    if self.ex is not None:
1382 varun.gupt 9593 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9594 
      self.ex.write(oprot)
9595 
      oprot.writeFieldEnd()
9596 
    oprot.writeFieldStop()
9597 
    oprot.writeStructEnd()
9598 
 
3431 rajveer 9599 
  def validate(self):
9600 
    return
9601 
 
9602 
 
1382 varun.gupt 9603 
  def __repr__(self):
9604 
    L = ['%s=%r' % (key, value)
9605 
      for key, value in self.__dict__.iteritems()]
9606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9607 
 
9608 
  def __eq__(self, other):
9609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9610 
 
9611 
  def __ne__(self, other):
9612 
    return not (self == other)
9613 
 
483 rajveer 9614 
class changeOrderStatus_args:
94 ashish 9615 
  """
9616 
  Attributes:
483 rajveer 9617 
   - orderId
9618 
   - status
9619 
   - description
94 ashish 9620 
  """
9621 
 
9622 
  thrift_spec = (
9623 
    None, # 0
483 rajveer 9624 
    (1, TType.I64, 'orderId', None, None, ), # 1
9625 
    (2, TType.I32, 'status', None, None, ), # 2
9626 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 9627 
  )
9628 
 
483 rajveer 9629 
  def __init__(self, orderId=None, status=None, description=None,):
9630 
    self.orderId = orderId
9631 
    self.status = status
9632 
    self.description = description
94 ashish 9633 
 
9634 
  def read(self, iprot):
9635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9637 
      return
9638 
    iprot.readStructBegin()
9639 
    while True:
9640 
      (fname, ftype, fid) = iprot.readFieldBegin()
9641 
      if ftype == TType.STOP:
9642 
        break
9643 
      if fid == 1:
9644 
        if ftype == TType.I64:
483 rajveer 9645 
          self.orderId = iprot.readI64();
94 ashish 9646 
        else:
9647 
          iprot.skip(ftype)
9648 
      elif fid == 2:
483 rajveer 9649 
        if ftype == TType.I32:
9650 
          self.status = iprot.readI32();
94 ashish 9651 
        else:
9652 
          iprot.skip(ftype)
483 rajveer 9653 
      elif fid == 3:
9654 
        if ftype == TType.STRING:
9655 
          self.description = iprot.readString();
9656 
        else:
9657 
          iprot.skip(ftype)
94 ashish 9658 
      else:
9659 
        iprot.skip(ftype)
9660 
      iprot.readFieldEnd()
9661 
    iprot.readStructEnd()
9662 
 
9663 
  def write(self, oprot):
9664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9666 
      return
483 rajveer 9667 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 9668 
    if self.orderId is not None:
483 rajveer 9669 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
9670 
      oprot.writeI64(self.orderId)
94 ashish 9671 
      oprot.writeFieldEnd()
3431 rajveer 9672 
    if self.status is not None:
483 rajveer 9673 
      oprot.writeFieldBegin('status', TType.I32, 2)
9674 
      oprot.writeI32(self.status)
94 ashish 9675 
      oprot.writeFieldEnd()
3431 rajveer 9676 
    if self.description is not None:
483 rajveer 9677 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9678 
      oprot.writeString(self.description)
9679 
      oprot.writeFieldEnd()
94 ashish 9680 
    oprot.writeFieldStop()
9681 
    oprot.writeStructEnd()
9682 
 
3431 rajveer 9683 
  def validate(self):
9684 
    return
9685 
 
9686 
 
94 ashish 9687 
  def __repr__(self):
9688 
    L = ['%s=%r' % (key, value)
9689 
      for key, value in self.__dict__.iteritems()]
9690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9691 
 
9692 
  def __eq__(self, other):
9693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9694 
 
9695 
  def __ne__(self, other):
9696 
    return not (self == other)
9697 
 
483 rajveer 9698 
class changeOrderStatus_result:
94 ashish 9699 
  """
9700 
  Attributes:
9701 
   - success
9702 
   - ex
9703 
  """
9704 
 
9705 
  thrift_spec = (
9706 
    (0, TType.BOOL, 'success', None, None, ), # 0
9707 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9708 
  )
9709 
 
9710 
  def __init__(self, success=None, ex=None,):
9711 
    self.success = success
9712 
    self.ex = ex
9713 
 
9714 
  def read(self, iprot):
9715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9717 
      return
9718 
    iprot.readStructBegin()
9719 
    while True:
9720 
      (fname, ftype, fid) = iprot.readFieldBegin()
9721 
      if ftype == TType.STOP:
9722 
        break
9723 
      if fid == 0:
9724 
        if ftype == TType.BOOL:
9725 
          self.success = iprot.readBool();
9726 
        else:
9727 
          iprot.skip(ftype)
9728 
      elif fid == 1:
9729 
        if ftype == TType.STRUCT:
9730 
          self.ex = TransactionServiceException()
9731 
          self.ex.read(iprot)
9732 
        else:
9733 
          iprot.skip(ftype)
9734 
      else:
9735 
        iprot.skip(ftype)
9736 
      iprot.readFieldEnd()
9737 
    iprot.readStructEnd()
9738 
 
9739 
  def write(self, oprot):
9740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9742 
      return
483 rajveer 9743 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 9744 
    if self.success is not None:
94 ashish 9745 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9746 
      oprot.writeBool(self.success)
9747 
      oprot.writeFieldEnd()
3431 rajveer 9748 
    if self.ex is not None:
94 ashish 9749 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9750 
      self.ex.write(oprot)
9751 
      oprot.writeFieldEnd()
9752 
    oprot.writeFieldStop()
9753 
    oprot.writeStructEnd()
9754 
 
3431 rajveer 9755 
  def validate(self):
9756 
    return
9757 
 
9758 
 
94 ashish 9759 
  def __repr__(self):
9760 
    L = ['%s=%r' % (key, value)
9761 
      for key, value in self.__dict__.iteritems()]
9762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9763 
 
9764 
  def __eq__(self, other):
9765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9766 
 
9767 
  def __ne__(self, other):
9768 
    return not (self == other)
9769 
 
3064 chandransh 9770 
class getOrdersForTransaction_args:
494 rajveer 9771 
  """
9772 
  Attributes:
3064 chandransh 9773 
   - transactionId
9774 
   - customerId
494 rajveer 9775 
  """
9776 
 
9777 
  thrift_spec = (
9778 
    None, # 0
3064 chandransh 9779 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9780 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 9781 
  )
9782 
 
3064 chandransh 9783 
  def __init__(self, transactionId=None, customerId=None,):
9784 
    self.transactionId = transactionId
9785 
    self.customerId = customerId
494 rajveer 9786 
 
9787 
  def read(self, iprot):
9788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9790 
      return
9791 
    iprot.readStructBegin()
9792 
    while True:
9793 
      (fname, ftype, fid) = iprot.readFieldBegin()
9794 
      if ftype == TType.STOP:
9795 
        break
9796 
      if fid == 1:
9797 
        if ftype == TType.I64:
3064 chandransh 9798 
          self.transactionId = iprot.readI64();
494 rajveer 9799 
        else:
9800 
          iprot.skip(ftype)
9801 
      elif fid == 2:
3064 chandransh 9802 
        if ftype == TType.I64:
9803 
          self.customerId = iprot.readI64();
494 rajveer 9804 
        else:
9805 
          iprot.skip(ftype)
9806 
      else:
9807 
        iprot.skip(ftype)
9808 
      iprot.readFieldEnd()
9809 
    iprot.readStructEnd()
9810 
 
9811 
  def write(self, oprot):
9812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9814 
      return
3064 chandransh 9815 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 9816 
    if self.transactionId is not None:
3064 chandransh 9817 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9818 
      oprot.writeI64(self.transactionId)
494 rajveer 9819 
      oprot.writeFieldEnd()
3431 rajveer 9820 
    if self.customerId is not None:
3064 chandransh 9821 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
9822 
      oprot.writeI64(self.customerId)
494 rajveer 9823 
      oprot.writeFieldEnd()
9824 
    oprot.writeFieldStop()
9825 
    oprot.writeStructEnd()
9826 
 
3431 rajveer 9827 
  def validate(self):
9828 
    return
9829 
 
9830 
 
494 rajveer 9831 
  def __repr__(self):
9832 
    L = ['%s=%r' % (key, value)
9833 
      for key, value in self.__dict__.iteritems()]
9834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9835 
 
9836 
  def __eq__(self, other):
9837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9838 
 
9839 
  def __ne__(self, other):
9840 
    return not (self == other)
9841 
 
3064 chandransh 9842 
class getOrdersForTransaction_result:
494 rajveer 9843 
  """
9844 
  Attributes:
9845 
   - success
9846 
   - ex
9847 
  """
9848 
 
9849 
  thrift_spec = (
3064 chandransh 9850 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 9851 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9852 
  )
9853 
 
9854 
  def __init__(self, success=None, ex=None,):
9855 
    self.success = success
9856 
    self.ex = ex
9857 
 
9858 
  def read(self, iprot):
9859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9861 
      return
9862 
    iprot.readStructBegin()
9863 
    while True:
9864 
      (fname, ftype, fid) = iprot.readFieldBegin()
9865 
      if ftype == TType.STOP:
9866 
        break
9867 
      if fid == 0:
3064 chandransh 9868 
        if ftype == TType.LIST:
9869 
          self.success = []
5031 varun.gupt 9870 
          (_etype143, _size140) = iprot.readListBegin()
9871 
          for _i144 in xrange(_size140):
9872 
            _elem145 = Order()
9873 
            _elem145.read(iprot)
9874 
            self.success.append(_elem145)
3064 chandransh 9875 
          iprot.readListEnd()
494 rajveer 9876 
        else:
9877 
          iprot.skip(ftype)
9878 
      elif fid == 1:
9879 
        if ftype == TType.STRUCT:
9880 
          self.ex = TransactionServiceException()
9881 
          self.ex.read(iprot)
9882 
        else:
9883 
          iprot.skip(ftype)
9884 
      else:
9885 
        iprot.skip(ftype)
9886 
      iprot.readFieldEnd()
9887 
    iprot.readStructEnd()
9888 
 
9889 
  def write(self, oprot):
9890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9892 
      return
3064 chandransh 9893 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 9894 
    if self.success is not None:
3064 chandransh 9895 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9896 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 9897 
      for iter146 in self.success:
9898 
        iter146.write(oprot)
3064 chandransh 9899 
      oprot.writeListEnd()
494 rajveer 9900 
      oprot.writeFieldEnd()
3431 rajveer 9901 
    if self.ex is not None:
494 rajveer 9902 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9903 
      self.ex.write(oprot)
9904 
      oprot.writeFieldEnd()
9905 
    oprot.writeFieldStop()
9906 
    oprot.writeStructEnd()
9907 
 
3431 rajveer 9908 
  def validate(self):
9909 
    return
9910 
 
9911 
 
494 rajveer 9912 
  def __repr__(self):
9913 
    L = ['%s=%r' % (key, value)
9914 
      for key, value in self.__dict__.iteritems()]
9915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9916 
 
9917 
  def __eq__(self, other):
9918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9919 
 
9920 
  def __ne__(self, other):
9921 
    return not (self == other)
9922 
 
3064 chandransh 9923 
class getOrdersForCustomer_args:
1149 chandransh 9924 
  """
9925 
  Attributes:
3064 chandransh 9926 
   - customerId
9927 
   - from_date
9928 
   - to_date
9929 
   - statuses
1149 chandransh 9930 
  """
9931 
 
9932 
  thrift_spec = (
9933 
    None, # 0
3064 chandransh 9934 
    (1, TType.I64, 'customerId', None, None, ), # 1
9935 
    (2, TType.I64, 'from_date', None, None, ), # 2
9936 
    (3, TType.I64, 'to_date', None, None, ), # 3
9937 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 9938 
  )
9939 
 
3064 chandransh 9940 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
9941 
    self.customerId = customerId
9942 
    self.from_date = from_date
9943 
    self.to_date = to_date
9944 
    self.statuses = statuses
1149 chandransh 9945 
 
9946 
  def read(self, iprot):
9947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9949 
      return
9950 
    iprot.readStructBegin()
9951 
    while True:
9952 
      (fname, ftype, fid) = iprot.readFieldBegin()
9953 
      if ftype == TType.STOP:
9954 
        break
9955 
      if fid == 1:
9956 
        if ftype == TType.I64:
3064 chandransh 9957 
          self.customerId = iprot.readI64();
1149 chandransh 9958 
        else:
9959 
          iprot.skip(ftype)
9960 
      elif fid == 2:
9961 
        if ftype == TType.I64:
3064 chandransh 9962 
          self.from_date = iprot.readI64();
1149 chandransh 9963 
        else:
9964 
          iprot.skip(ftype)
2783 chandransh 9965 
      elif fid == 3:
9966 
        if ftype == TType.I64:
3064 chandransh 9967 
          self.to_date = iprot.readI64();
2783 chandransh 9968 
        else:
9969 
          iprot.skip(ftype)
9970 
      elif fid == 4:
3064 chandransh 9971 
        if ftype == TType.LIST:
9972 
          self.statuses = []
5031 varun.gupt 9973 
          (_etype150, _size147) = iprot.readListBegin()
9974 
          for _i151 in xrange(_size147):
9975 
            _elem152 = iprot.readI32();
9976 
            self.statuses.append(_elem152)
3064 chandransh 9977 
          iprot.readListEnd()
2783 chandransh 9978 
        else:
9979 
          iprot.skip(ftype)
1149 chandransh 9980 
      else:
9981 
        iprot.skip(ftype)
9982 
      iprot.readFieldEnd()
9983 
    iprot.readStructEnd()
9984 
 
9985 
  def write(self, oprot):
9986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9988 
      return
3064 chandransh 9989 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 9990 
    if self.customerId is not None:
3064 chandransh 9991 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9992 
      oprot.writeI64(self.customerId)
1149 chandransh 9993 
      oprot.writeFieldEnd()
3431 rajveer 9994 
    if self.from_date is not None:
3064 chandransh 9995 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9996 
      oprot.writeI64(self.from_date)
1149 chandransh 9997 
      oprot.writeFieldEnd()
3431 rajveer 9998 
    if self.to_date is not None:
3064 chandransh 9999 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10000 
      oprot.writeI64(self.to_date)
2783 chandransh 10001 
      oprot.writeFieldEnd()
3431 rajveer 10002 
    if self.statuses is not None:
3064 chandransh 10003 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
10004 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5031 varun.gupt 10005 
      for iter153 in self.statuses:
10006 
        oprot.writeI32(iter153)
3064 chandransh 10007 
      oprot.writeListEnd()
2783 chandransh 10008 
      oprot.writeFieldEnd()
1149 chandransh 10009 
    oprot.writeFieldStop()
10010 
    oprot.writeStructEnd()
10011 
 
3431 rajveer 10012 
  def validate(self):
10013 
    return
10014 
 
10015 
 
1149 chandransh 10016 
  def __repr__(self):
10017 
    L = ['%s=%r' % (key, value)
10018 
      for key, value in self.__dict__.iteritems()]
10019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10020 
 
10021 
  def __eq__(self, other):
10022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10023 
 
10024 
  def __ne__(self, other):
10025 
    return not (self == other)
10026 
 
3064 chandransh 10027 
class getOrdersForCustomer_result:
1149 chandransh 10028 
  """
10029 
  Attributes:
10030 
   - success
10031 
   - ex
10032 
  """
10033 
 
10034 
  thrift_spec = (
3064 chandransh 10035 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 10036 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10037 
  )
10038 
 
10039 
  def __init__(self, success=None, ex=None,):
10040 
    self.success = success
10041 
    self.ex = ex
10042 
 
10043 
  def read(self, iprot):
10044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10046 
      return
10047 
    iprot.readStructBegin()
10048 
    while True:
10049 
      (fname, ftype, fid) = iprot.readFieldBegin()
10050 
      if ftype == TType.STOP:
10051 
        break
10052 
      if fid == 0:
3064 chandransh 10053 
        if ftype == TType.LIST:
10054 
          self.success = []
5031 varun.gupt 10055 
          (_etype157, _size154) = iprot.readListBegin()
10056 
          for _i158 in xrange(_size154):
10057 
            _elem159 = Order()
10058 
            _elem159.read(iprot)
10059 
            self.success.append(_elem159)
3064 chandransh 10060 
          iprot.readListEnd()
1149 chandransh 10061 
        else:
10062 
          iprot.skip(ftype)
10063 
      elif fid == 1:
10064 
        if ftype == TType.STRUCT:
10065 
          self.ex = TransactionServiceException()
10066 
          self.ex.read(iprot)
10067 
        else:
10068 
          iprot.skip(ftype)
10069 
      else:
10070 
        iprot.skip(ftype)
10071 
      iprot.readFieldEnd()
10072 
    iprot.readStructEnd()
10073 
 
10074 
  def write(self, oprot):
10075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10077 
      return
3064 chandransh 10078 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 10079 
    if self.success is not None:
3064 chandransh 10080 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10081 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10082 
      for iter160 in self.success:
10083 
        iter160.write(oprot)
3064 chandransh 10084 
      oprot.writeListEnd()
1149 chandransh 10085 
      oprot.writeFieldEnd()
3431 rajveer 10086 
    if self.ex is not None:
1149 chandransh 10087 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10088 
      self.ex.write(oprot)
10089 
      oprot.writeFieldEnd()
10090 
    oprot.writeFieldStop()
10091 
    oprot.writeStructEnd()
10092 
 
3431 rajveer 10093 
  def validate(self):
10094 
    return
10095 
 
10096 
 
1149 chandransh 10097 
  def __repr__(self):
10098 
    L = ['%s=%r' % (key, value)
10099 
      for key, value in self.__dict__.iteritems()]
10100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10101 
 
10102 
  def __eq__(self, other):
10103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10104 
 
10105 
  def __ne__(self, other):
10106 
    return not (self == other)
10107 
 
3064 chandransh 10108 
class createOrder_args:
921 rajveer 10109 
  """
10110 
  Attributes:
3064 chandransh 10111 
   - order
921 rajveer 10112 
  """
10113 
 
10114 
  thrift_spec = (
10115 
    None, # 0
3064 chandransh 10116 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 10117 
  )
10118 
 
3064 chandransh 10119 
  def __init__(self, order=None,):
10120 
    self.order = order
921 rajveer 10121 
 
10122 
  def read(self, iprot):
10123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10125 
      return
10126 
    iprot.readStructBegin()
10127 
    while True:
10128 
      (fname, ftype, fid) = iprot.readFieldBegin()
10129 
      if ftype == TType.STOP:
10130 
        break
10131 
      if fid == 1:
3064 chandransh 10132 
        if ftype == TType.STRUCT:
10133 
          self.order = Order()
10134 
          self.order.read(iprot)
921 rajveer 10135 
        else:
10136 
          iprot.skip(ftype)
10137 
      else:
10138 
        iprot.skip(ftype)
10139 
      iprot.readFieldEnd()
10140 
    iprot.readStructEnd()
10141 
 
10142 
  def write(self, oprot):
10143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10145 
      return
3064 chandransh 10146 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 10147 
    if self.order is not None:
3064 chandransh 10148 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
10149 
      self.order.write(oprot)
921 rajveer 10150 
      oprot.writeFieldEnd()
10151 
    oprot.writeFieldStop()
10152 
    oprot.writeStructEnd()
10153 
 
3431 rajveer 10154 
  def validate(self):
10155 
    return
10156 
 
10157 
 
921 rajveer 10158 
  def __repr__(self):
10159 
    L = ['%s=%r' % (key, value)
10160 
      for key, value in self.__dict__.iteritems()]
10161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10162 
 
10163 
  def __eq__(self, other):
10164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10165 
 
10166 
  def __ne__(self, other):
10167 
    return not (self == other)
10168 
 
3064 chandransh 10169 
class createOrder_result:
921 rajveer 10170 
  """
10171 
  Attributes:
10172 
   - success
10173 
   - ex
10174 
  """
10175 
 
10176 
  thrift_spec = (
3064 chandransh 10177 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 10178 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10179 
  )
10180 
 
10181 
  def __init__(self, success=None, ex=None,):
10182 
    self.success = success
10183 
    self.ex = ex
10184 
 
10185 
  def read(self, iprot):
10186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10188 
      return
10189 
    iprot.readStructBegin()
10190 
    while True:
10191 
      (fname, ftype, fid) = iprot.readFieldBegin()
10192 
      if ftype == TType.STOP:
10193 
        break
10194 
      if fid == 0:
3064 chandransh 10195 
        if ftype == TType.I64:
10196 
          self.success = iprot.readI64();
921 rajveer 10197 
        else:
10198 
          iprot.skip(ftype)
10199 
      elif fid == 1:
10200 
        if ftype == TType.STRUCT:
10201 
          self.ex = TransactionServiceException()
10202 
          self.ex.read(iprot)
10203 
        else:
10204 
          iprot.skip(ftype)
10205 
      else:
10206 
        iprot.skip(ftype)
10207 
      iprot.readFieldEnd()
10208 
    iprot.readStructEnd()
10209 
 
10210 
  def write(self, oprot):
10211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10213 
      return
3064 chandransh 10214 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 10215 
    if self.success is not None:
3064 chandransh 10216 
      oprot.writeFieldBegin('success', TType.I64, 0)
10217 
      oprot.writeI64(self.success)
921 rajveer 10218 
      oprot.writeFieldEnd()
3431 rajveer 10219 
    if self.ex is not None:
921 rajveer 10220 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10221 
      self.ex.write(oprot)
10222 
      oprot.writeFieldEnd()
10223 
    oprot.writeFieldStop()
10224 
    oprot.writeStructEnd()
10225 
 
3431 rajveer 10226 
  def validate(self):
10227 
    return
10228 
 
10229 
 
921 rajveer 10230 
  def __repr__(self):
10231 
    L = ['%s=%r' % (key, value)
10232 
      for key, value in self.__dict__.iteritems()]
10233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10234 
 
10235 
  def __eq__(self, other):
10236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10237 
 
10238 
  def __ne__(self, other):
10239 
    return not (self == other)
10240 
 
3064 chandransh 10241 
class getOrder_args:
921 rajveer 10242 
  """
10243 
  Attributes:
3064 chandransh 10244 
   - id
921 rajveer 10245 
  """
10246 
 
10247 
  thrift_spec = (
10248 
    None, # 0
3064 chandransh 10249 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 10250 
  )
10251 
 
3064 chandransh 10252 
  def __init__(self, id=None,):
10253 
    self.id = id
921 rajveer 10254 
 
10255 
  def read(self, iprot):
10256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10258 
      return
10259 
    iprot.readStructBegin()
10260 
    while True:
10261 
      (fname, ftype, fid) = iprot.readFieldBegin()
10262 
      if ftype == TType.STOP:
10263 
        break
10264 
      if fid == 1:
10265 
        if ftype == TType.I64:
3064 chandransh 10266 
          self.id = iprot.readI64();
921 rajveer 10267 
        else:
10268 
          iprot.skip(ftype)
10269 
      else:
10270 
        iprot.skip(ftype)
10271 
      iprot.readFieldEnd()
10272 
    iprot.readStructEnd()
10273 
 
10274 
  def write(self, oprot):
10275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10277 
      return
3064 chandransh 10278 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 10279 
    if self.id is not None:
3064 chandransh 10280 
      oprot.writeFieldBegin('id', TType.I64, 1)
10281 
      oprot.writeI64(self.id)
921 rajveer 10282 
      oprot.writeFieldEnd()
10283 
    oprot.writeFieldStop()
10284 
    oprot.writeStructEnd()
10285 
 
3431 rajveer 10286 
  def validate(self):
10287 
    return
10288 
 
10289 
 
921 rajveer 10290 
  def __repr__(self):
10291 
    L = ['%s=%r' % (key, value)
10292 
      for key, value in self.__dict__.iteritems()]
10293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10294 
 
10295 
  def __eq__(self, other):
10296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10297 
 
10298 
  def __ne__(self, other):
10299 
    return not (self == other)
10300 
 
3064 chandransh 10301 
class getOrder_result:
921 rajveer 10302 
  """
10303 
  Attributes:
10304 
   - success
10305 
   - ex
10306 
  """
10307 
 
10308 
  thrift_spec = (
3064 chandransh 10309 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 10310 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10311 
  )
10312 
 
10313 
  def __init__(self, success=None, ex=None,):
10314 
    self.success = success
10315 
    self.ex = ex
10316 
 
10317 
  def read(self, iprot):
10318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10320 
      return
10321 
    iprot.readStructBegin()
10322 
    while True:
10323 
      (fname, ftype, fid) = iprot.readFieldBegin()
10324 
      if ftype == TType.STOP:
10325 
        break
10326 
      if fid == 0:
3064 chandransh 10327 
        if ftype == TType.STRUCT:
10328 
          self.success = Order()
10329 
          self.success.read(iprot)
921 rajveer 10330 
        else:
10331 
          iprot.skip(ftype)
10332 
      elif fid == 1:
10333 
        if ftype == TType.STRUCT:
10334 
          self.ex = TransactionServiceException()
10335 
          self.ex.read(iprot)
10336 
        else:
10337 
          iprot.skip(ftype)
10338 
      else:
10339 
        iprot.skip(ftype)
10340 
      iprot.readFieldEnd()
10341 
    iprot.readStructEnd()
10342 
 
10343 
  def write(self, oprot):
10344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10346 
      return
3064 chandransh 10347 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 10348 
    if self.success is not None:
3064 chandransh 10349 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10350 
      self.success.write(oprot)
921 rajveer 10351 
      oprot.writeFieldEnd()
3431 rajveer 10352 
    if self.ex is not None:
921 rajveer 10353 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10354 
      self.ex.write(oprot)
10355 
      oprot.writeFieldEnd()
10356 
    oprot.writeFieldStop()
10357 
    oprot.writeStructEnd()
10358 
 
3431 rajveer 10359 
  def validate(self):
10360 
    return
10361 
 
10362 
 
921 rajveer 10363 
  def __repr__(self):
10364 
    L = ['%s=%r' % (key, value)
10365 
      for key, value in self.__dict__.iteritems()]
10366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10367 
 
10368 
  def __eq__(self, other):
10369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10370 
 
10371 
  def __ne__(self, other):
10372 
    return not (self == other)
10373 
 
3064 chandransh 10374 
class getLineItemsForOrder_args:
94 ashish 10375 
  """
10376 
  Attributes:
3064 chandransh 10377 
   - orderId
94 ashish 10378 
  """
10379 
 
10380 
  thrift_spec = (
10381 
    None, # 0
3064 chandransh 10382 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 10383 
  )
10384 
 
3064 chandransh 10385 
  def __init__(self, orderId=None,):
10386 
    self.orderId = orderId
94 ashish 10387 
 
10388 
  def read(self, iprot):
10389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10391 
      return
10392 
    iprot.readStructBegin()
10393 
    while True:
10394 
      (fname, ftype, fid) = iprot.readFieldBegin()
10395 
      if ftype == TType.STOP:
10396 
        break
10397 
      if fid == 1:
10398 
        if ftype == TType.I64:
3064 chandransh 10399 
          self.orderId = iprot.readI64();
94 ashish 10400 
        else:
10401 
          iprot.skip(ftype)
10402 
      else:
10403 
        iprot.skip(ftype)
10404 
      iprot.readFieldEnd()
10405 
    iprot.readStructEnd()
10406 
 
10407 
  def write(self, oprot):
10408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10410 
      return
3064 chandransh 10411 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 10412 
    if self.orderId is not None:
3064 chandransh 10413 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10414 
      oprot.writeI64(self.orderId)
94 ashish 10415 
      oprot.writeFieldEnd()
10416 
    oprot.writeFieldStop()
10417 
    oprot.writeStructEnd()
10418 
 
3431 rajveer 10419 
  def validate(self):
10420 
    return
10421 
 
10422 
 
94 ashish 10423 
  def __repr__(self):
10424 
    L = ['%s=%r' % (key, value)
10425 
      for key, value in self.__dict__.iteritems()]
10426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10427 
 
10428 
  def __eq__(self, other):
10429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10430 
 
10431 
  def __ne__(self, other):
10432 
    return not (self == other)
10433 
 
3064 chandransh 10434 
class getLineItemsForOrder_result:
94 ashish 10435 
  """
10436 
  Attributes:
10437 
   - success
10438 
   - ex
10439 
  """
10440 
 
10441 
  thrift_spec = (
3064 chandransh 10442 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 10443 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10444 
  )
10445 
 
10446 
  def __init__(self, success=None, ex=None,):
10447 
    self.success = success
10448 
    self.ex = ex
10449 
 
10450 
  def read(self, iprot):
10451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10453 
      return
10454 
    iprot.readStructBegin()
10455 
    while True:
10456 
      (fname, ftype, fid) = iprot.readFieldBegin()
10457 
      if ftype == TType.STOP:
10458 
        break
10459 
      if fid == 0:
483 rajveer 10460 
        if ftype == TType.LIST:
10461 
          self.success = []
5031 varun.gupt 10462 
          (_etype164, _size161) = iprot.readListBegin()
10463 
          for _i165 in xrange(_size161):
10464 
            _elem166 = LineItem()
10465 
            _elem166.read(iprot)
10466 
            self.success.append(_elem166)
483 rajveer 10467 
          iprot.readListEnd()
94 ashish 10468 
        else:
10469 
          iprot.skip(ftype)
10470 
      elif fid == 1:
10471 
        if ftype == TType.STRUCT:
10472 
          self.ex = TransactionServiceException()
10473 
          self.ex.read(iprot)
10474 
        else:
10475 
          iprot.skip(ftype)
10476 
      else:
10477 
        iprot.skip(ftype)
10478 
      iprot.readFieldEnd()
10479 
    iprot.readStructEnd()
10480 
 
10481 
  def write(self, oprot):
10482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10484 
      return
3064 chandransh 10485 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 10486 
    if self.success is not None:
483 rajveer 10487 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10488 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10489 
      for iter167 in self.success:
10490 
        iter167.write(oprot)
483 rajveer 10491 
      oprot.writeListEnd()
94 ashish 10492 
      oprot.writeFieldEnd()
3431 rajveer 10493 
    if self.ex is not None:
94 ashish 10494 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10495 
      self.ex.write(oprot)
10496 
      oprot.writeFieldEnd()
10497 
    oprot.writeFieldStop()
10498 
    oprot.writeStructEnd()
10499 
 
3431 rajveer 10500 
  def validate(self):
10501 
    return
10502 
 
10503 
 
94 ashish 10504 
  def __repr__(self):
10505 
    L = ['%s=%r' % (key, value)
10506 
      for key, value in self.__dict__.iteritems()]
10507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10508 
 
10509 
  def __eq__(self, other):
10510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10511 
 
10512 
  def __ne__(self, other):
10513 
    return not (self == other)
10514 
 
4999 phani.kuma 10515 
class getOrderList_args:
10516 
  """
10517 
  Attributes:
10518 
   - order_ids
10519 
  """
10520 
 
10521 
  thrift_spec = (
10522 
    None, # 0
10523 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10524 
  )
10525 
 
10526 
  def __init__(self, order_ids=None,):
10527 
    self.order_ids = order_ids
10528 
 
10529 
  def read(self, iprot):
10530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10532 
      return
10533 
    iprot.readStructBegin()
10534 
    while True:
10535 
      (fname, ftype, fid) = iprot.readFieldBegin()
10536 
      if ftype == TType.STOP:
10537 
        break
10538 
      if fid == 1:
10539 
        if ftype == TType.LIST:
10540 
          self.order_ids = []
5031 varun.gupt 10541 
          (_etype171, _size168) = iprot.readListBegin()
10542 
          for _i172 in xrange(_size168):
10543 
            _elem173 = iprot.readI64();
10544 
            self.order_ids.append(_elem173)
4999 phani.kuma 10545 
          iprot.readListEnd()
10546 
        else:
10547 
          iprot.skip(ftype)
10548 
      else:
10549 
        iprot.skip(ftype)
10550 
      iprot.readFieldEnd()
10551 
    iprot.readStructEnd()
10552 
 
10553 
  def write(self, oprot):
10554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10556 
      return
10557 
    oprot.writeStructBegin('getOrderList_args')
10558 
    if self.order_ids is not None:
10559 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10560 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
5031 varun.gupt 10561 
      for iter174 in self.order_ids:
10562 
        oprot.writeI64(iter174)
4999 phani.kuma 10563 
      oprot.writeListEnd()
10564 
      oprot.writeFieldEnd()
10565 
    oprot.writeFieldStop()
10566 
    oprot.writeStructEnd()
10567 
 
10568 
  def validate(self):
10569 
    return
10570 
 
10571 
 
10572 
  def __repr__(self):
10573 
    L = ['%s=%r' % (key, value)
10574 
      for key, value in self.__dict__.iteritems()]
10575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10576 
 
10577 
  def __eq__(self, other):
10578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10579 
 
10580 
  def __ne__(self, other):
10581 
    return not (self == other)
10582 
 
10583 
class getOrderList_result:
10584 
  """
10585 
  Attributes:
10586 
   - success
10587 
  """
10588 
 
10589 
  thrift_spec = (
10590 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10591 
  )
10592 
 
10593 
  def __init__(self, success=None,):
10594 
    self.success = success
10595 
 
10596 
  def read(self, iprot):
10597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10599 
      return
10600 
    iprot.readStructBegin()
10601 
    while True:
10602 
      (fname, ftype, fid) = iprot.readFieldBegin()
10603 
      if ftype == TType.STOP:
10604 
        break
10605 
      if fid == 0:
10606 
        if ftype == TType.LIST:
10607 
          self.success = []
5031 varun.gupt 10608 
          (_etype178, _size175) = iprot.readListBegin()
10609 
          for _i179 in xrange(_size175):
10610 
            _elem180 = Order()
10611 
            _elem180.read(iprot)
10612 
            self.success.append(_elem180)
4999 phani.kuma 10613 
          iprot.readListEnd()
10614 
        else:
10615 
          iprot.skip(ftype)
10616 
      else:
10617 
        iprot.skip(ftype)
10618 
      iprot.readFieldEnd()
10619 
    iprot.readStructEnd()
10620 
 
10621 
  def write(self, oprot):
10622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10624 
      return
10625 
    oprot.writeStructBegin('getOrderList_result')
10626 
    if self.success is not None:
10627 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10628 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5031 varun.gupt 10629 
      for iter181 in self.success:
10630 
        iter181.write(oprot)
4999 phani.kuma 10631 
      oprot.writeListEnd()
10632 
      oprot.writeFieldEnd()
10633 
    oprot.writeFieldStop()
10634 
    oprot.writeStructEnd()
10635 
 
10636 
  def validate(self):
10637 
    return
10638 
 
10639 
 
10640 
  def __repr__(self):
10641 
    L = ['%s=%r' % (key, value)
10642 
      for key, value in self.__dict__.iteritems()]
10643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10644 
 
10645 
  def __eq__(self, other):
10646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10647 
 
10648 
  def __ne__(self, other):
10649 
    return not (self == other)
10650 
 
5386 phani.kuma 10651 
class getOrderListForVendor_args:
10652 
  """
10653 
  Attributes:
10654 
   - order_ids
10655 
   - vendorId
10656 
  """
10657 
 
10658 
  thrift_spec = (
10659 
    None, # 0
10660 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
10661 
    (2, TType.I64, 'vendorId', None, None, ), # 2
10662 
  )
10663 
 
10664 
  def __init__(self, order_ids=None, vendorId=None,):
10665 
    self.order_ids = order_ids
10666 
    self.vendorId = vendorId
10667 
 
10668 
  def read(self, iprot):
10669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10671 
      return
10672 
    iprot.readStructBegin()
10673 
    while True:
10674 
      (fname, ftype, fid) = iprot.readFieldBegin()
10675 
      if ftype == TType.STOP:
10676 
        break
10677 
      if fid == 1:
10678 
        if ftype == TType.LIST:
10679 
          self.order_ids = []
10680 
          (_etype185, _size182) = iprot.readListBegin()
10681 
          for _i186 in xrange(_size182):
10682 
            _elem187 = iprot.readI64();
10683 
            self.order_ids.append(_elem187)
10684 
          iprot.readListEnd()
10685 
        else:
10686 
          iprot.skip(ftype)
10687 
      elif fid == 2:
10688 
        if ftype == TType.I64:
10689 
          self.vendorId = iprot.readI64();
10690 
        else:
10691 
          iprot.skip(ftype)
10692 
      else:
10693 
        iprot.skip(ftype)
10694 
      iprot.readFieldEnd()
10695 
    iprot.readStructEnd()
10696 
 
10697 
  def write(self, oprot):
10698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10700 
      return
10701 
    oprot.writeStructBegin('getOrderListForVendor_args')
10702 
    if self.order_ids is not None:
10703 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
10704 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
10705 
      for iter188 in self.order_ids:
10706 
        oprot.writeI64(iter188)
10707 
      oprot.writeListEnd()
10708 
      oprot.writeFieldEnd()
10709 
    if self.vendorId is not None:
10710 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
10711 
      oprot.writeI64(self.vendorId)
10712 
      oprot.writeFieldEnd()
10713 
    oprot.writeFieldStop()
10714 
    oprot.writeStructEnd()
10715 
 
10716 
  def validate(self):
10717 
    return
10718 
 
10719 
 
10720 
  def __repr__(self):
10721 
    L = ['%s=%r' % (key, value)
10722 
      for key, value in self.__dict__.iteritems()]
10723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10724 
 
10725 
  def __eq__(self, other):
10726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10727 
 
10728 
  def __ne__(self, other):
10729 
    return not (self == other)
10730 
 
10731 
class getOrderListForVendor_result:
10732 
  """
10733 
  Attributes:
10734 
   - success
10735 
  """
10736 
 
10737 
  thrift_spec = (
10738 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10739 
  )
10740 
 
10741 
  def __init__(self, success=None,):
10742 
    self.success = success
10743 
 
10744 
  def read(self, iprot):
10745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10747 
      return
10748 
    iprot.readStructBegin()
10749 
    while True:
10750 
      (fname, ftype, fid) = iprot.readFieldBegin()
10751 
      if ftype == TType.STOP:
10752 
        break
10753 
      if fid == 0:
10754 
        if ftype == TType.LIST:
10755 
          self.success = []
10756 
          (_etype192, _size189) = iprot.readListBegin()
10757 
          for _i193 in xrange(_size189):
10758 
            _elem194 = Order()
10759 
            _elem194.read(iprot)
10760 
            self.success.append(_elem194)
10761 
          iprot.readListEnd()
10762 
        else:
10763 
          iprot.skip(ftype)
10764 
      else:
10765 
        iprot.skip(ftype)
10766 
      iprot.readFieldEnd()
10767 
    iprot.readStructEnd()
10768 
 
10769 
  def write(self, oprot):
10770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10772 
      return
10773 
    oprot.writeStructBegin('getOrderListForVendor_result')
10774 
    if self.success is not None:
10775 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10776 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10777 
      for iter195 in self.success:
10778 
        iter195.write(oprot)
10779 
      oprot.writeListEnd()
10780 
      oprot.writeFieldEnd()
10781 
    oprot.writeFieldStop()
10782 
    oprot.writeStructEnd()
10783 
 
10784 
  def validate(self):
10785 
    return
10786 
 
10787 
 
10788 
  def __repr__(self):
10789 
    L = ['%s=%r' % (key, value)
10790 
      for key, value in self.__dict__.iteritems()]
10791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10792 
 
10793 
  def __eq__(self, other):
10794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10795 
 
10796 
  def __ne__(self, other):
10797 
    return not (self == other)
10798 
 
3064 chandransh 10799 
class getOrderForCustomer_args:
94 ashish 10800 
  """
10801 
  Attributes:
3064 chandransh 10802 
   - orderId
483 rajveer 10803 
   - customerId
94 ashish 10804 
  """
10805 
 
10806 
  thrift_spec = (
10807 
    None, # 0
3064 chandransh 10808 
    (1, TType.I64, 'orderId', None, None, ), # 1
10809 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 10810 
  )
10811 
 
3064 chandransh 10812 
  def __init__(self, orderId=None, customerId=None,):
10813 
    self.orderId = orderId
483 rajveer 10814 
    self.customerId = customerId
94 ashish 10815 
 
10816 
  def read(self, iprot):
10817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10819 
      return
10820 
    iprot.readStructBegin()
10821 
    while True:
10822 
      (fname, ftype, fid) = iprot.readFieldBegin()
10823 
      if ftype == TType.STOP:
10824 
        break
10825 
      if fid == 1:
10826 
        if ftype == TType.I64:
3064 chandransh 10827 
          self.orderId = iprot.readI64();
94 ashish 10828 
        else:
10829 
          iprot.skip(ftype)
10830 
      elif fid == 2:
10831 
        if ftype == TType.I64:
3064 chandransh 10832 
          self.customerId = iprot.readI64();
94 ashish 10833 
        else:
10834 
          iprot.skip(ftype)
10835 
      else:
10836 
        iprot.skip(ftype)
10837 
      iprot.readFieldEnd()
10838 
    iprot.readStructEnd()
10839 
 
10840 
  def write(self, oprot):
10841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10843 
      return
3064 chandransh 10844 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 10845 
    if self.orderId is not None:
3064 chandransh 10846 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10847 
      oprot.writeI64(self.orderId)
10848 
      oprot.writeFieldEnd()
3431 rajveer 10849 
    if self.customerId is not None:
3064 chandransh 10850 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 10851 
      oprot.writeI64(self.customerId)
94 ashish 10852 
      oprot.writeFieldEnd()
10853 
    oprot.writeFieldStop()
10854 
    oprot.writeStructEnd()
10855 
 
3431 rajveer 10856 
  def validate(self):
10857 
    return
10858 
 
10859 
 
94 ashish 10860 
  def __repr__(self):
10861 
    L = ['%s=%r' % (key, value)
10862 
      for key, value in self.__dict__.iteritems()]
10863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10864 
 
10865 
  def __eq__(self, other):
10866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10867 
 
10868 
  def __ne__(self, other):
10869 
    return not (self == other)
10870 
 
3064 chandransh 10871 
class getOrderForCustomer_result:
94 ashish 10872 
  """
10873 
  Attributes:
10874 
   - success
10875 
   - ex
10876 
  """
10877 
 
10878 
  thrift_spec = (
3064 chandransh 10879 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 10880 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10881 
  )
10882 
 
10883 
  def __init__(self, success=None, ex=None,):
10884 
    self.success = success
10885 
    self.ex = ex
10886 
 
10887 
  def read(self, iprot):
10888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10890 
      return
10891 
    iprot.readStructBegin()
10892 
    while True:
10893 
      (fname, ftype, fid) = iprot.readFieldBegin()
10894 
      if ftype == TType.STOP:
10895 
        break
10896 
      if fid == 0:
3064 chandransh 10897 
        if ftype == TType.STRUCT:
10898 
          self.success = Order()
10899 
          self.success.read(iprot)
94 ashish 10900 
        else:
10901 
          iprot.skip(ftype)
10902 
      elif fid == 1:
10903 
        if ftype == TType.STRUCT:
10904 
          self.ex = TransactionServiceException()
10905 
          self.ex.read(iprot)
10906 
        else:
10907 
          iprot.skip(ftype)
10908 
      else:
10909 
        iprot.skip(ftype)
10910 
      iprot.readFieldEnd()
10911 
    iprot.readStructEnd()
10912 
 
10913 
  def write(self, oprot):
10914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10916 
      return
3064 chandransh 10917 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 10918 
    if self.success is not None:
3064 chandransh 10919 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10920 
      self.success.write(oprot)
94 ashish 10921 
      oprot.writeFieldEnd()
3431 rajveer 10922 
    if self.ex is not None:
94 ashish 10923 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10924 
      self.ex.write(oprot)
10925 
      oprot.writeFieldEnd()
10926 
    oprot.writeFieldStop()
10927 
    oprot.writeStructEnd()
10928 
 
3431 rajveer 10929 
  def validate(self):
10930 
    return
10931 
 
10932 
 
94 ashish 10933 
  def __repr__(self):
10934 
    L = ['%s=%r' % (key, value)
10935 
      for key, value in self.__dict__.iteritems()]
10936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10937 
 
10938 
  def __eq__(self, other):
10939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10940 
 
10941 
  def __ne__(self, other):
10942 
    return not (self == other)
10943 
 
3064 chandransh 10944 
class getAlerts_args:
94 ashish 10945 
  """
10946 
  Attributes:
4394 rajveer 10947 
   - type
4444 rajveer 10948 
   - warehouseId
4394 rajveer 10949 
   - status
10950 
   - timestamp
94 ashish 10951 
  """
10952 
 
10953 
  thrift_spec = (
10954 
    None, # 0
4394 rajveer 10955 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 10956 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10957 
    (3, TType.I64, 'status', None, None, ), # 3
10958 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 10959 
  )
10960 
 
4444 rajveer 10961 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 10962 
    self.type = type
4444 rajveer 10963 
    self.warehouseId = warehouseId
4394 rajveer 10964 
    self.status = status
10965 
    self.timestamp = timestamp
94 ashish 10966 
 
10967 
  def read(self, iprot):
10968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10970 
      return
10971 
    iprot.readStructBegin()
10972 
    while True:
10973 
      (fname, ftype, fid) = iprot.readFieldBegin()
10974 
      if ftype == TType.STOP:
10975 
        break
10976 
      if fid == 1:
3064 chandransh 10977 
        if ftype == TType.I64:
4394 rajveer 10978 
          self.type = iprot.readI64();
94 ashish 10979 
        else:
10980 
          iprot.skip(ftype)
3064 chandransh 10981 
      elif fid == 2:
4394 rajveer 10982 
        if ftype == TType.I64:
4444 rajveer 10983 
          self.warehouseId = iprot.readI64();
3064 chandransh 10984 
        else:
10985 
          iprot.skip(ftype)
4394 rajveer 10986 
      elif fid == 3:
10987 
        if ftype == TType.I64:
4444 rajveer 10988 
          self.status = iprot.readI64();
10989 
        else:
10990 
          iprot.skip(ftype)
10991 
      elif fid == 4:
10992 
        if ftype == TType.I64:
4394 rajveer 10993 
          self.timestamp = iprot.readI64();
10994 
        else:
10995 
          iprot.skip(ftype)
94 ashish 10996 
      else:
10997 
        iprot.skip(ftype)
10998 
      iprot.readFieldEnd()
10999 
    iprot.readStructEnd()
11000 
 
11001 
  def write(self, oprot):
11002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11004 
      return
3064 chandransh 11005 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 11006 
    if self.type is not None:
11007 
      oprot.writeFieldBegin('type', TType.I64, 1)
11008 
      oprot.writeI64(self.type)
94 ashish 11009 
      oprot.writeFieldEnd()
4444 rajveer 11010 
    if self.warehouseId is not None:
11011 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11012 
      oprot.writeI64(self.warehouseId)
11013 
      oprot.writeFieldEnd()
4394 rajveer 11014 
    if self.status is not None:
4444 rajveer 11015 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 11016 
      oprot.writeI64(self.status)
3064 chandransh 11017 
      oprot.writeFieldEnd()
4394 rajveer 11018 
    if self.timestamp is not None:
4444 rajveer 11019 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 11020 
      oprot.writeI64(self.timestamp)
11021 
      oprot.writeFieldEnd()
94 ashish 11022 
    oprot.writeFieldStop()
11023 
    oprot.writeStructEnd()
11024 
 
3431 rajveer 11025 
  def validate(self):
11026 
    return
11027 
 
11028 
 
94 ashish 11029 
  def __repr__(self):
11030 
    L = ['%s=%r' % (key, value)
11031 
      for key, value in self.__dict__.iteritems()]
11032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11033 
 
11034 
  def __eq__(self, other):
11035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11036 
 
11037 
  def __ne__(self, other):
11038 
    return not (self == other)
11039 
 
3064 chandransh 11040 
class getAlerts_result:
94 ashish 11041 
  """
11042 
  Attributes:
11043 
   - success
11044 
  """
11045 
 
11046 
  thrift_spec = (
3064 chandransh 11047 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 11048 
  )
11049 
 
3064 chandransh 11050 
  def __init__(self, success=None,):
94 ashish 11051 
    self.success = success
11052 
 
11053 
  def read(self, iprot):
11054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11056 
      return
11057 
    iprot.readStructBegin()
11058 
    while True:
11059 
      (fname, ftype, fid) = iprot.readFieldBegin()
11060 
      if ftype == TType.STOP:
11061 
        break
11062 
      if fid == 0:
3064 chandransh 11063 
        if ftype == TType.LIST:
11064 
          self.success = []
5386 phani.kuma 11065 
          (_etype199, _size196) = iprot.readListBegin()
11066 
          for _i200 in xrange(_size196):
11067 
            _elem201 = Alert()
11068 
            _elem201.read(iprot)
11069 
            self.success.append(_elem201)
3064 chandransh 11070 
          iprot.readListEnd()
94 ashish 11071 
        else:
11072 
          iprot.skip(ftype)
11073 
      else:
11074 
        iprot.skip(ftype)
11075 
      iprot.readFieldEnd()
11076 
    iprot.readStructEnd()
11077 
 
11078 
  def write(self, oprot):
11079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11081 
      return
3064 chandransh 11082 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 11083 
    if self.success is not None:
3064 chandransh 11084 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11085 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11086 
      for iter202 in self.success:
11087 
        iter202.write(oprot)
3064 chandransh 11088 
      oprot.writeListEnd()
94 ashish 11089 
      oprot.writeFieldEnd()
11090 
    oprot.writeFieldStop()
11091 
    oprot.writeStructEnd()
11092 
 
3431 rajveer 11093 
  def validate(self):
11094 
    return
11095 
 
11096 
 
94 ashish 11097 
  def __repr__(self):
11098 
    L = ['%s=%r' % (key, value)
11099 
      for key, value in self.__dict__.iteritems()]
11100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11101 
 
11102 
  def __eq__(self, other):
11103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11104 
 
11105 
  def __ne__(self, other):
11106 
    return not (self == other)
11107 
 
4394 rajveer 11108 
class addAlert_args:
94 ashish 11109 
  """
11110 
  Attributes:
3064 chandransh 11111 
   - type
4444 rajveer 11112 
   - warehouseId
4394 rajveer 11113 
   - description
94 ashish 11114 
  """
11115 
 
11116 
  thrift_spec = (
11117 
    None, # 0
4394 rajveer 11118 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11119 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11120 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11121 
  )
11122 
 
4444 rajveer 11123 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 11124 
    self.type = type
4444 rajveer 11125 
    self.warehouseId = warehouseId
4394 rajveer 11126 
    self.description = description
94 ashish 11127 
 
11128 
  def read(self, iprot):
11129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11131 
      return
11132 
    iprot.readStructBegin()
11133 
    while True:
11134 
      (fname, ftype, fid) = iprot.readFieldBegin()
11135 
      if ftype == TType.STOP:
11136 
        break
11137 
      if fid == 1:
11138 
        if ftype == TType.I64:
4394 rajveer 11139 
          self.type = iprot.readI64();
94 ashish 11140 
        else:
11141 
          iprot.skip(ftype)
3064 chandransh 11142 
      elif fid == 2:
4444 rajveer 11143 
        if ftype == TType.I64:
11144 
          self.warehouseId = iprot.readI64();
11145 
        else:
11146 
          iprot.skip(ftype)
11147 
      elif fid == 3:
3064 chandransh 11148 
        if ftype == TType.STRING:
4394 rajveer 11149 
          self.description = iprot.readString();
3064 chandransh 11150 
        else:
11151 
          iprot.skip(ftype)
94 ashish 11152 
      else:
11153 
        iprot.skip(ftype)
11154 
      iprot.readFieldEnd()
11155 
    iprot.readStructEnd()
11156 
 
11157 
  def write(self, oprot):
11158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11160 
      return
4394 rajveer 11161 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 11162 
    if self.type is not None:
4394 rajveer 11163 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 11164 
      oprot.writeI64(self.type)
11165 
      oprot.writeFieldEnd()
4444 rajveer 11166 
    if self.warehouseId is not None:
11167 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11168 
      oprot.writeI64(self.warehouseId)
11169 
      oprot.writeFieldEnd()
4394 rajveer 11170 
    if self.description is not None:
4444 rajveer 11171 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 11172 
      oprot.writeString(self.description)
3064 chandransh 11173 
      oprot.writeFieldEnd()
94 ashish 11174 
    oprot.writeFieldStop()
11175 
    oprot.writeStructEnd()
11176 
 
3431 rajveer 11177 
  def validate(self):
11178 
    return
11179 
 
11180 
 
94 ashish 11181 
  def __repr__(self):
11182 
    L = ['%s=%r' % (key, value)
11183 
      for key, value in self.__dict__.iteritems()]
11184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11185 
 
11186 
  def __eq__(self, other):
11187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11188 
 
11189 
  def __ne__(self, other):
11190 
    return not (self == other)
11191 
 
4394 rajveer 11192 
class addAlert_result:
3064 chandransh 11193 
 
11194 
  thrift_spec = (
11195 
  )
11196 
 
11197 
  def read(self, iprot):
11198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11200 
      return
11201 
    iprot.readStructBegin()
11202 
    while True:
11203 
      (fname, ftype, fid) = iprot.readFieldBegin()
11204 
      if ftype == TType.STOP:
11205 
        break
11206 
      else:
11207 
        iprot.skip(ftype)
11208 
      iprot.readFieldEnd()
11209 
    iprot.readStructEnd()
11210 
 
11211 
  def write(self, oprot):
11212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11214 
      return
4394 rajveer 11215 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 11216 
    oprot.writeFieldStop()
11217 
    oprot.writeStructEnd()
11218 
 
3431 rajveer 11219 
  def validate(self):
11220 
    return
11221 
 
11222 
 
3064 chandransh 11223 
  def __repr__(self):
11224 
    L = ['%s=%r' % (key, value)
11225 
      for key, value in self.__dict__.iteritems()]
11226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11227 
 
11228 
  def __eq__(self, other):
11229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11230 
 
11231 
  def __ne__(self, other):
11232 
    return not (self == other)
11233 
 
4444 rajveer 11234 
class markAlertsAsSeen_args:
11235 
  """
11236 
  Attributes:
11237 
   - warehouseId
11238 
  """
11239 
 
11240 
  thrift_spec = (
11241 
    None, # 0
11242 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11243 
  )
11244 
 
11245 
  def __init__(self, warehouseId=None,):
11246 
    self.warehouseId = warehouseId
11247 
 
11248 
  def read(self, iprot):
11249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11251 
      return
11252 
    iprot.readStructBegin()
11253 
    while True:
11254 
      (fname, ftype, fid) = iprot.readFieldBegin()
11255 
      if ftype == TType.STOP:
11256 
        break
11257 
      if fid == 1:
11258 
        if ftype == TType.I64:
11259 
          self.warehouseId = iprot.readI64();
11260 
        else:
11261 
          iprot.skip(ftype)
11262 
      else:
11263 
        iprot.skip(ftype)
11264 
      iprot.readFieldEnd()
11265 
    iprot.readStructEnd()
11266 
 
11267 
  def write(self, oprot):
11268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11270 
      return
11271 
    oprot.writeStructBegin('markAlertsAsSeen_args')
11272 
    if self.warehouseId is not None:
11273 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11274 
      oprot.writeI64(self.warehouseId)
11275 
      oprot.writeFieldEnd()
11276 
    oprot.writeFieldStop()
11277 
    oprot.writeStructEnd()
11278 
 
11279 
  def validate(self):
11280 
    return
11281 
 
11282 
 
11283 
  def __repr__(self):
11284 
    L = ['%s=%r' % (key, value)
11285 
      for key, value in self.__dict__.iteritems()]
11286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11287 
 
11288 
  def __eq__(self, other):
11289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11290 
 
11291 
  def __ne__(self, other):
11292 
    return not (self == other)
11293 
 
11294 
class markAlertsAsSeen_result:
11295 
 
11296 
  thrift_spec = (
11297 
  )
11298 
 
11299 
  def read(self, iprot):
11300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11302 
      return
11303 
    iprot.readStructBegin()
11304 
    while True:
11305 
      (fname, ftype, fid) = iprot.readFieldBegin()
11306 
      if ftype == TType.STOP:
11307 
        break
11308 
      else:
11309 
        iprot.skip(ftype)
11310 
      iprot.readFieldEnd()
11311 
    iprot.readStructEnd()
11312 
 
11313 
  def write(self, oprot):
11314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11316 
      return
11317 
    oprot.writeStructBegin('markAlertsAsSeen_result')
11318 
    oprot.writeFieldStop()
11319 
    oprot.writeStructEnd()
11320 
 
11321 
  def validate(self):
11322 
    return
11323 
 
11324 
 
11325 
  def __repr__(self):
11326 
    L = ['%s=%r' % (key, value)
11327 
      for key, value in self.__dict__.iteritems()]
11328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11329 
 
11330 
  def __eq__(self, other):
11331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11332 
 
11333 
  def __ne__(self, other):
11334 
    return not (self == other)
11335 
 
3064 chandransh 11336 
class getValidOrderCount_args:
11337 
 
11338 
  thrift_spec = (
11339 
  )
11340 
 
11341 
  def read(self, iprot):
11342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11344 
      return
11345 
    iprot.readStructBegin()
11346 
    while True:
11347 
      (fname, ftype, fid) = iprot.readFieldBegin()
11348 
      if ftype == TType.STOP:
11349 
        break
11350 
      else:
11351 
        iprot.skip(ftype)
11352 
      iprot.readFieldEnd()
11353 
    iprot.readStructEnd()
11354 
 
11355 
  def write(self, oprot):
11356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11358 
      return
11359 
    oprot.writeStructBegin('getValidOrderCount_args')
11360 
    oprot.writeFieldStop()
11361 
    oprot.writeStructEnd()
11362 
 
3431 rajveer 11363 
  def validate(self):
11364 
    return
11365 
 
11366 
 
3064 chandransh 11367 
  def __repr__(self):
11368 
    L = ['%s=%r' % (key, value)
11369 
      for key, value in self.__dict__.iteritems()]
11370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11371 
 
11372 
  def __eq__(self, other):
11373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11374 
 
11375 
  def __ne__(self, other):
11376 
    return not (self == other)
11377 
 
11378 
class getValidOrderCount_result:
94 ashish 11379 
  """
11380 
  Attributes:
11381 
   - success
11382 
  """
11383 
 
11384 
  thrift_spec = (
3064 chandransh 11385 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11386 
  )
11387 
 
3064 chandransh 11388 
  def __init__(self, success=None,):
94 ashish 11389 
    self.success = success
11390 
 
11391 
  def read(self, iprot):
11392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11394 
      return
11395 
    iprot.readStructBegin()
11396 
    while True:
11397 
      (fname, ftype, fid) = iprot.readFieldBegin()
11398 
      if ftype == TType.STOP:
11399 
        break
11400 
      if fid == 0:
3064 chandransh 11401 
        if ftype == TType.I64:
11402 
          self.success = iprot.readI64();
94 ashish 11403 
        else:
11404 
          iprot.skip(ftype)
11405 
      else:
11406 
        iprot.skip(ftype)
11407 
      iprot.readFieldEnd()
11408 
    iprot.readStructEnd()
11409 
 
11410 
  def write(self, oprot):
11411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11413 
      return
3064 chandransh 11414 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 11415 
    if self.success is not None:
3064 chandransh 11416 
      oprot.writeFieldBegin('success', TType.I64, 0)
11417 
      oprot.writeI64(self.success)
94 ashish 11418 
      oprot.writeFieldEnd()
11419 
    oprot.writeFieldStop()
11420 
    oprot.writeStructEnd()
11421 
 
3431 rajveer 11422 
  def validate(self):
11423 
    return
11424 
 
11425 
 
94 ashish 11426 
  def __repr__(self):
11427 
    L = ['%s=%r' % (key, value)
11428 
      for key, value in self.__dict__.iteritems()]
11429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11430 
 
11431 
  def __eq__(self, other):
11432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11433 
 
11434 
  def __ne__(self, other):
11435 
    return not (self == other)
11436 
 
3064 chandransh 11437 
class getNoOfCustomersWithSuccessfulTransaction_args:
11438 
 
11439 
  thrift_spec = (
11440 
  )
11441 
 
11442 
  def read(self, iprot):
11443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11445 
      return
11446 
    iprot.readStructBegin()
11447 
    while True:
11448 
      (fname, ftype, fid) = iprot.readFieldBegin()
11449 
      if ftype == TType.STOP:
11450 
        break
11451 
      else:
11452 
        iprot.skip(ftype)
11453 
      iprot.readFieldEnd()
11454 
    iprot.readStructEnd()
11455 
 
11456 
  def write(self, oprot):
11457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11459 
      return
11460 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
11461 
    oprot.writeFieldStop()
11462 
    oprot.writeStructEnd()
11463 
 
3431 rajveer 11464 
  def validate(self):
11465 
    return
11466 
 
11467 
 
3064 chandransh 11468 
  def __repr__(self):
11469 
    L = ['%s=%r' % (key, value)
11470 
      for key, value in self.__dict__.iteritems()]
11471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11472 
 
11473 
  def __eq__(self, other):
11474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11475 
 
11476 
  def __ne__(self, other):
11477 
    return not (self == other)
11478 
 
11479 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 11480 
  """
11481 
  Attributes:
3064 chandransh 11482 
   - success
94 ashish 11483 
  """
11484 
 
11485 
  thrift_spec = (
3064 chandransh 11486 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11487 
  )
11488 
 
3064 chandransh 11489 
  def __init__(self, success=None,):
11490 
    self.success = success
94 ashish 11491 
 
11492 
  def read(self, iprot):
11493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11495 
      return
11496 
    iprot.readStructBegin()
11497 
    while True:
11498 
      (fname, ftype, fid) = iprot.readFieldBegin()
11499 
      if ftype == TType.STOP:
11500 
        break
3064 chandransh 11501 
      if fid == 0:
94 ashish 11502 
        if ftype == TType.I64:
3064 chandransh 11503 
          self.success = iprot.readI64();
94 ashish 11504 
        else:
11505 
          iprot.skip(ftype)
11506 
      else:
11507 
        iprot.skip(ftype)
11508 
      iprot.readFieldEnd()
11509 
    iprot.readStructEnd()
11510 
 
11511 
  def write(self, oprot):
11512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11514 
      return
3064 chandransh 11515 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 11516 
    if self.success is not None:
3064 chandransh 11517 
      oprot.writeFieldBegin('success', TType.I64, 0)
11518 
      oprot.writeI64(self.success)
94 ashish 11519 
      oprot.writeFieldEnd()
11520 
    oprot.writeFieldStop()
11521 
    oprot.writeStructEnd()
11522 
 
3431 rajveer 11523 
  def validate(self):
11524 
    return
11525 
 
11526 
 
94 ashish 11527 
  def __repr__(self):
11528 
    L = ['%s=%r' % (key, value)
11529 
      for key, value in self.__dict__.iteritems()]
11530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11531 
 
11532 
  def __eq__(self, other):
11533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11534 
 
11535 
  def __ne__(self, other):
11536 
    return not (self == other)
11537 
 
3064 chandransh 11538 
class getValidOrdersAmountRange_args:
11539 
 
11540 
  thrift_spec = (
11541 
  )
11542 
 
11543 
  def read(self, iprot):
11544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11546 
      return
11547 
    iprot.readStructBegin()
11548 
    while True:
11549 
      (fname, ftype, fid) = iprot.readFieldBegin()
11550 
      if ftype == TType.STOP:
11551 
        break
11552 
      else:
11553 
        iprot.skip(ftype)
11554 
      iprot.readFieldEnd()
11555 
    iprot.readStructEnd()
11556 
 
11557 
  def write(self, oprot):
11558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11560 
      return
11561 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
11562 
    oprot.writeFieldStop()
11563 
    oprot.writeStructEnd()
11564 
 
3431 rajveer 11565 
  def validate(self):
11566 
    return
11567 
 
11568 
 
3064 chandransh 11569 
  def __repr__(self):
11570 
    L = ['%s=%r' % (key, value)
11571 
      for key, value in self.__dict__.iteritems()]
11572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11573 
 
11574 
  def __eq__(self, other):
11575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11576 
 
11577 
  def __ne__(self, other):
11578 
    return not (self == other)
11579 
 
11580 
class getValidOrdersAmountRange_result:
94 ashish 11581 
  """
11582 
  Attributes:
11583 
   - success
11584 
  """
11585 
 
11586 
  thrift_spec = (
3064 chandransh 11587 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 11588 
  )
11589 
 
3064 chandransh 11590 
  def __init__(self, success=None,):
94 ashish 11591 
    self.success = success
11592 
 
11593 
  def read(self, iprot):
11594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11596 
      return
11597 
    iprot.readStructBegin()
11598 
    while True:
11599 
      (fname, ftype, fid) = iprot.readFieldBegin()
11600 
      if ftype == TType.STOP:
11601 
        break
11602 
      if fid == 0:
483 rajveer 11603 
        if ftype == TType.LIST:
11604 
          self.success = []
5386 phani.kuma 11605 
          (_etype206, _size203) = iprot.readListBegin()
11606 
          for _i207 in xrange(_size203):
11607 
            _elem208 = iprot.readDouble();
11608 
            self.success.append(_elem208)
483 rajveer 11609 
          iprot.readListEnd()
94 ashish 11610 
        else:
11611 
          iprot.skip(ftype)
11612 
      else:
11613 
        iprot.skip(ftype)
11614 
      iprot.readFieldEnd()
11615 
    iprot.readStructEnd()
11616 
 
11617 
  def write(self, oprot):
11618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11620 
      return
3064 chandransh 11621 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 11622 
    if self.success is not None:
483 rajveer 11623 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 11624 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
5386 phani.kuma 11625 
      for iter209 in self.success:
11626 
        oprot.writeDouble(iter209)
483 rajveer 11627 
      oprot.writeListEnd()
94 ashish 11628 
      oprot.writeFieldEnd()
11629 
    oprot.writeFieldStop()
11630 
    oprot.writeStructEnd()
11631 
 
3431 rajveer 11632 
  def validate(self):
11633 
    return
11634 
 
11635 
 
94 ashish 11636 
  def __repr__(self):
11637 
    L = ['%s=%r' % (key, value)
11638 
      for key, value in self.__dict__.iteritems()]
11639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11640 
 
11641 
  def __eq__(self, other):
11642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11643 
 
11644 
  def __ne__(self, other):
11645 
    return not (self == other)
11646 
 
3064 chandransh 11647 
class getValidOrders_args:
1528 ankur.sing 11648 
  """
11649 
  Attributes:
3064 chandransh 11650 
   - limit
1528 ankur.sing 11651 
  """
11652 
 
11653 
  thrift_spec = (
11654 
    None, # 0
3064 chandransh 11655 
    (1, TType.I64, 'limit', None, None, ), # 1
1528 ankur.sing 11656 
  )
11657 
 
3064 chandransh 11658 
  def __init__(self, limit=None,):
11659 
    self.limit = limit
1528 ankur.sing 11660 
 
11661 
  def read(self, iprot):
11662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11664 
      return
11665 
    iprot.readStructBegin()
11666 
    while True:
11667 
      (fname, ftype, fid) = iprot.readFieldBegin()
11668 
      if ftype == TType.STOP:
11669 
        break
11670 
      if fid == 1:
11671 
        if ftype == TType.I64:
3064 chandransh 11672 
          self.limit = iprot.readI64();
1528 ankur.sing 11673 
        else:
11674 
          iprot.skip(ftype)
11675 
      else:
11676 
        iprot.skip(ftype)
11677 
      iprot.readFieldEnd()
11678 
    iprot.readStructEnd()
11679 
 
11680 
  def write(self, oprot):
11681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11683 
      return
3064 chandransh 11684 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 11685 
    if self.limit is not None:
3064 chandransh 11686 
      oprot.writeFieldBegin('limit', TType.I64, 1)
11687 
      oprot.writeI64(self.limit)
1528 ankur.sing 11688 
      oprot.writeFieldEnd()
11689 
    oprot.writeFieldStop()
11690 
    oprot.writeStructEnd()
11691 
 
3431 rajveer 11692 
  def validate(self):
11693 
    return
11694 
 
11695 
 
1528 ankur.sing 11696 
  def __repr__(self):
11697 
    L = ['%s=%r' % (key, value)
11698 
      for key, value in self.__dict__.iteritems()]
11699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11700 
 
11701 
  def __eq__(self, other):
11702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11703 
 
11704 
  def __ne__(self, other):
11705 
    return not (self == other)
11706 
 
3064 chandransh 11707 
class getValidOrders_result:
1528 ankur.sing 11708 
  """
11709 
  Attributes:
11710 
   - success
11711 
  """
11712 
 
11713 
  thrift_spec = (
3064 chandransh 11714 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 11715 
  )
11716 
 
3064 chandransh 11717 
  def __init__(self, success=None,):
1528 ankur.sing 11718 
    self.success = success
11719 
 
11720 
  def read(self, iprot):
11721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11723 
      return
11724 
    iprot.readStructBegin()
11725 
    while True:
11726 
      (fname, ftype, fid) = iprot.readFieldBegin()
11727 
      if ftype == TType.STOP:
11728 
        break
11729 
      if fid == 0:
3064 chandransh 11730 
        if ftype == TType.LIST:
11731 
          self.success = []
5386 phani.kuma 11732 
          (_etype213, _size210) = iprot.readListBegin()
11733 
          for _i214 in xrange(_size210):
11734 
            _elem215 = Order()
11735 
            _elem215.read(iprot)
11736 
            self.success.append(_elem215)
3064 chandransh 11737 
          iprot.readListEnd()
1528 ankur.sing 11738 
        else:
11739 
          iprot.skip(ftype)
11740 
      else:
11741 
        iprot.skip(ftype)
11742 
      iprot.readFieldEnd()
11743 
    iprot.readStructEnd()
11744 
 
11745 
  def write(self, oprot):
11746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11748 
      return
3064 chandransh 11749 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 11750 
    if self.success is not None:
3064 chandransh 11751 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11752 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11753 
      for iter216 in self.success:
11754 
        iter216.write(oprot)
3064 chandransh 11755 
      oprot.writeListEnd()
1528 ankur.sing 11756 
      oprot.writeFieldEnd()
11757 
    oprot.writeFieldStop()
11758 
    oprot.writeStructEnd()
11759 
 
3431 rajveer 11760 
  def validate(self):
11761 
    return
11762 
 
11763 
 
1528 ankur.sing 11764 
  def __repr__(self):
11765 
    L = ['%s=%r' % (key, value)
11766 
      for key, value in self.__dict__.iteritems()]
11767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11768 
 
11769 
  def __eq__(self, other):
11770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11771 
 
11772 
  def __ne__(self, other):
11773 
    return not (self == other)
11774 
 
1220 chandransh 11775 
class batchOrders_args:
11776 
  """
11777 
  Attributes:
11778 
   - warehouseId
11779 
  """
11780 
 
11781 
  thrift_spec = (
11782 
    None, # 0
11783 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
11784 
  )
11785 
 
11786 
  def __init__(self, warehouseId=None,):
11787 
    self.warehouseId = warehouseId
11788 
 
11789 
  def read(self, iprot):
11790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11792 
      return
11793 
    iprot.readStructBegin()
11794 
    while True:
11795 
      (fname, ftype, fid) = iprot.readFieldBegin()
11796 
      if ftype == TType.STOP:
11797 
        break
11798 
      if fid == 1:
11799 
        if ftype == TType.I64:
11800 
          self.warehouseId = iprot.readI64();
11801 
        else:
11802 
          iprot.skip(ftype)
11803 
      else:
11804 
        iprot.skip(ftype)
11805 
      iprot.readFieldEnd()
11806 
    iprot.readStructEnd()
11807 
 
11808 
  def write(self, oprot):
11809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11811 
      return
11812 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 11813 
    if self.warehouseId is not None:
1220 chandransh 11814 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
11815 
      oprot.writeI64(self.warehouseId)
11816 
      oprot.writeFieldEnd()
11817 
    oprot.writeFieldStop()
11818 
    oprot.writeStructEnd()
11819 
 
3431 rajveer 11820 
  def validate(self):
11821 
    return
11822 
 
11823 
 
1220 chandransh 11824 
  def __repr__(self):
11825 
    L = ['%s=%r' % (key, value)
11826 
      for key, value in self.__dict__.iteritems()]
11827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11828 
 
11829 
  def __eq__(self, other):
11830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11831 
 
11832 
  def __ne__(self, other):
11833 
    return not (self == other)
11834 
 
11835 
class batchOrders_result:
11836 
  """
11837 
  Attributes:
11838 
   - success
11839 
   - ex
11840 
  """
11841 
 
11842 
  thrift_spec = (
11843 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11844 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11845 
  )
11846 
 
11847 
  def __init__(self, success=None, ex=None,):
11848 
    self.success = success
11849 
    self.ex = ex
11850 
 
11851 
  def read(self, iprot):
11852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11854 
      return
11855 
    iprot.readStructBegin()
11856 
    while True:
11857 
      (fname, ftype, fid) = iprot.readFieldBegin()
11858 
      if ftype == TType.STOP:
11859 
        break
11860 
      if fid == 0:
11861 
        if ftype == TType.LIST:
11862 
          self.success = []
5386 phani.kuma 11863 
          (_etype220, _size217) = iprot.readListBegin()
11864 
          for _i221 in xrange(_size217):
11865 
            _elem222 = Order()
11866 
            _elem222.read(iprot)
11867 
            self.success.append(_elem222)
1220 chandransh 11868 
          iprot.readListEnd()
11869 
        else:
11870 
          iprot.skip(ftype)
11871 
      elif fid == 1:
11872 
        if ftype == TType.STRUCT:
11873 
          self.ex = TransactionServiceException()
11874 
          self.ex.read(iprot)
11875 
        else:
11876 
          iprot.skip(ftype)
11877 
      else:
11878 
        iprot.skip(ftype)
11879 
      iprot.readFieldEnd()
11880 
    iprot.readStructEnd()
11881 
 
11882 
  def write(self, oprot):
11883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11885 
      return
11886 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 11887 
    if self.success is not None:
1220 chandransh 11888 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11889 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5386 phani.kuma 11890 
      for iter223 in self.success:
11891 
        iter223.write(oprot)
1220 chandransh 11892 
      oprot.writeListEnd()
11893 
      oprot.writeFieldEnd()
3431 rajveer 11894 
    if self.ex is not None:
1220 chandransh 11895 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11896 
      self.ex.write(oprot)
11897 
      oprot.writeFieldEnd()
11898 
    oprot.writeFieldStop()
11899 
    oprot.writeStructEnd()
11900 
 
3431 rajveer 11901 
  def validate(self):
11902 
    return
11903 
 
11904 
 
1220 chandransh 11905 
  def __repr__(self):
11906 
    L = ['%s=%r' % (key, value)
11907 
      for key, value in self.__dict__.iteritems()]
11908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11909 
 
11910 
  def __eq__(self, other):
11911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11912 
 
11913 
  def __ne__(self, other):
11914 
    return not (self == other)
11915 
 
1208 chandransh 11916 
class markOrderAsOutOfStock_args:
11917 
  """
11918 
  Attributes:
11919 
   - orderId
11920 
  """
11921 
 
11922 
  thrift_spec = (
11923 
    None, # 0
11924 
    (1, TType.I64, 'orderId', None, None, ), # 1
11925 
  )
11926 
 
11927 
  def __init__(self, orderId=None,):
11928 
    self.orderId = orderId
11929 
 
11930 
  def read(self, iprot):
11931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11933 
      return
11934 
    iprot.readStructBegin()
11935 
    while True:
11936 
      (fname, ftype, fid) = iprot.readFieldBegin()
11937 
      if ftype == TType.STOP:
11938 
        break
11939 
      if fid == 1:
11940 
        if ftype == TType.I64:
11941 
          self.orderId = iprot.readI64();
11942 
        else:
11943 
          iprot.skip(ftype)
11944 
      else:
11945 
        iprot.skip(ftype)
11946 
      iprot.readFieldEnd()
11947 
    iprot.readStructEnd()
11948 
 
11949 
  def write(self, oprot):
11950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11952 
      return
11953 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 11954 
    if self.orderId is not None:
1208 chandransh 11955 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11956 
      oprot.writeI64(self.orderId)
11957 
      oprot.writeFieldEnd()
11958 
    oprot.writeFieldStop()
11959 
    oprot.writeStructEnd()
11960 
 
3431 rajveer 11961 
  def validate(self):
11962 
    return
11963 
 
11964 
 
1208 chandransh 11965 
  def __repr__(self):
11966 
    L = ['%s=%r' % (key, value)
11967 
      for key, value in self.__dict__.iteritems()]
11968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11969 
 
11970 
  def __eq__(self, other):
11971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11972 
 
11973 
  def __ne__(self, other):
11974 
    return not (self == other)
11975 
 
11976 
class markOrderAsOutOfStock_result:
11977 
  """
11978 
  Attributes:
11979 
   - success
11980 
   - ex
11981 
  """
11982 
 
11983 
  thrift_spec = (
11984 
    (0, TType.BOOL, 'success', None, None, ), # 0
11985 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11986 
  )
11987 
 
11988 
  def __init__(self, success=None, ex=None,):
11989 
    self.success = success
11990 
    self.ex = ex
11991 
 
11992 
  def read(self, iprot):
11993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11995 
      return
11996 
    iprot.readStructBegin()
11997 
    while True:
11998 
      (fname, ftype, fid) = iprot.readFieldBegin()
11999 
      if ftype == TType.STOP:
12000 
        break
12001 
      if fid == 0:
12002 
        if ftype == TType.BOOL:
12003 
          self.success = iprot.readBool();
12004 
        else:
12005 
          iprot.skip(ftype)
12006 
      elif fid == 1:
12007 
        if ftype == TType.STRUCT:
12008 
          self.ex = TransactionServiceException()
12009 
          self.ex.read(iprot)
12010 
        else:
12011 
          iprot.skip(ftype)
12012 
      else:
12013 
        iprot.skip(ftype)
12014 
      iprot.readFieldEnd()
12015 
    iprot.readStructEnd()
12016 
 
12017 
  def write(self, oprot):
12018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12020 
      return
12021 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 12022 
    if self.success is not None:
1208 chandransh 12023 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12024 
      oprot.writeBool(self.success)
12025 
      oprot.writeFieldEnd()
3431 rajveer 12026 
    if self.ex is not None:
1208 chandransh 12027 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12028 
      self.ex.write(oprot)
12029 
      oprot.writeFieldEnd()
12030 
    oprot.writeFieldStop()
12031 
    oprot.writeStructEnd()
12032 
 
3431 rajveer 12033 
  def validate(self):
12034 
    return
12035 
 
12036 
 
1208 chandransh 12037 
  def __repr__(self):
12038 
    L = ['%s=%r' % (key, value)
12039 
      for key, value in self.__dict__.iteritems()]
12040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12041 
 
12042 
  def __eq__(self, other):
12043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12044 
 
12045 
  def __ne__(self, other):
12046 
    return not (self == other)
12047 
 
3064 chandransh 12048 
class verifyOrder_args:
759 chandransh 12049 
  """
12050 
  Attributes:
3064 chandransh 12051 
   - orderId
759 chandransh 12052 
  """
12053 
 
12054 
  thrift_spec = (
12055 
    None, # 0
3064 chandransh 12056 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 12057 
  )
12058 
 
3064 chandransh 12059 
  def __init__(self, orderId=None,):
12060 
    self.orderId = orderId
759 chandransh 12061 
 
12062 
  def read(self, iprot):
12063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12065 
      return
12066 
    iprot.readStructBegin()
12067 
    while True:
12068 
      (fname, ftype, fid) = iprot.readFieldBegin()
12069 
      if ftype == TType.STOP:
12070 
        break
12071 
      if fid == 1:
12072 
        if ftype == TType.I64:
3064 chandransh 12073 
          self.orderId = iprot.readI64();
759 chandransh 12074 
        else:
12075 
          iprot.skip(ftype)
12076 
      else:
12077 
        iprot.skip(ftype)
12078 
      iprot.readFieldEnd()
12079 
    iprot.readStructEnd()
12080 
 
12081 
  def write(self, oprot):
12082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12084 
      return
3064 chandransh 12085 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 12086 
    if self.orderId is not None:
3064 chandransh 12087 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12088 
      oprot.writeI64(self.orderId)
759 chandransh 12089 
      oprot.writeFieldEnd()
12090 
    oprot.writeFieldStop()
12091 
    oprot.writeStructEnd()
12092 
 
3431 rajveer 12093 
  def validate(self):
12094 
    return
12095 
 
12096 
 
759 chandransh 12097 
  def __repr__(self):
12098 
    L = ['%s=%r' % (key, value)
12099 
      for key, value in self.__dict__.iteritems()]
12100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12101 
 
12102 
  def __eq__(self, other):
12103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12104 
 
12105 
  def __ne__(self, other):
12106 
    return not (self == other)
12107 
 
3064 chandransh 12108 
class verifyOrder_result:
759 chandransh 12109 
  """
12110 
  Attributes:
12111 
   - success
12112 
   - ex
12113 
  """
12114 
 
12115 
  thrift_spec = (
12116 
    (0, TType.BOOL, 'success', None, None, ), # 0
12117 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12118 
  )
12119 
 
12120 
  def __init__(self, success=None, ex=None,):
12121 
    self.success = success
12122 
    self.ex = ex
12123 
 
12124 
  def read(self, iprot):
12125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12127 
      return
12128 
    iprot.readStructBegin()
12129 
    while True:
12130 
      (fname, ftype, fid) = iprot.readFieldBegin()
12131 
      if ftype == TType.STOP:
12132 
        break
12133 
      if fid == 0:
12134 
        if ftype == TType.BOOL:
12135 
          self.success = iprot.readBool();
12136 
        else:
12137 
          iprot.skip(ftype)
12138 
      elif fid == 1:
12139 
        if ftype == TType.STRUCT:
12140 
          self.ex = TransactionServiceException()
12141 
          self.ex.read(iprot)
12142 
        else:
12143 
          iprot.skip(ftype)
12144 
      else:
12145 
        iprot.skip(ftype)
12146 
      iprot.readFieldEnd()
12147 
    iprot.readStructEnd()
12148 
 
12149 
  def write(self, oprot):
12150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12152 
      return
3064 chandransh 12153 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 12154 
    if self.success is not None:
759 chandransh 12155 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12156 
      oprot.writeBool(self.success)
12157 
      oprot.writeFieldEnd()
3431 rajveer 12158 
    if self.ex is not None:
759 chandransh 12159 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12160 
      self.ex.write(oprot)
12161 
      oprot.writeFieldEnd()
12162 
    oprot.writeFieldStop()
12163 
    oprot.writeStructEnd()
12164 
 
3431 rajveer 12165 
  def validate(self):
12166 
    return
12167 
 
12168 
 
759 chandransh 12169 
  def __repr__(self):
12170 
    L = ['%s=%r' % (key, value)
12171 
      for key, value in self.__dict__.iteritems()]
12172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12173 
 
12174 
  def __eq__(self, other):
12175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12176 
 
12177 
  def __ne__(self, other):
12178 
    return not (self == other)
12179 
 
3064 chandransh 12180 
class acceptOrder_args:
1113 chandransh 12181 
  """
12182 
  Attributes:
3064 chandransh 12183 
   - orderId
1113 chandransh 12184 
  """
12185 
 
12186 
  thrift_spec = (
12187 
    None, # 0
3064 chandransh 12188 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 12189 
  )
12190 
 
3064 chandransh 12191 
  def __init__(self, orderId=None,):
12192 
    self.orderId = orderId
1113 chandransh 12193 
 
12194 
  def read(self, iprot):
12195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12197 
      return
12198 
    iprot.readStructBegin()
12199 
    while True:
12200 
      (fname, ftype, fid) = iprot.readFieldBegin()
12201 
      if ftype == TType.STOP:
12202 
        break
12203 
      if fid == 1:
12204 
        if ftype == TType.I64:
3064 chandransh 12205 
          self.orderId = iprot.readI64();
1113 chandransh 12206 
        else:
12207 
          iprot.skip(ftype)
12208 
      else:
12209 
        iprot.skip(ftype)
12210 
      iprot.readFieldEnd()
12211 
    iprot.readStructEnd()
12212 
 
12213 
  def write(self, oprot):
12214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12216 
      return
3064 chandransh 12217 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 12218 
    if self.orderId is not None:
3064 chandransh 12219 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12220 
      oprot.writeI64(self.orderId)
1113 chandransh 12221 
      oprot.writeFieldEnd()
12222 
    oprot.writeFieldStop()
12223 
    oprot.writeStructEnd()
12224 
 
3431 rajveer 12225 
  def validate(self):
12226 
    return
12227 
 
12228 
 
1113 chandransh 12229 
  def __repr__(self):
12230 
    L = ['%s=%r' % (key, value)
12231 
      for key, value in self.__dict__.iteritems()]
12232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12233 
 
12234 
  def __eq__(self, other):
12235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12236 
 
12237 
  def __ne__(self, other):
12238 
    return not (self == other)
12239 
 
3064 chandransh 12240 
class acceptOrder_result:
1113 chandransh 12241 
  """
12242 
  Attributes:
12243 
   - success
12244 
   - ex
12245 
  """
12246 
 
12247 
  thrift_spec = (
3064 chandransh 12248 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 12249 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12250 
  )
12251 
 
12252 
  def __init__(self, success=None, ex=None,):
12253 
    self.success = success
12254 
    self.ex = ex
12255 
 
12256 
  def read(self, iprot):
12257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12259 
      return
12260 
    iprot.readStructBegin()
12261 
    while True:
12262 
      (fname, ftype, fid) = iprot.readFieldBegin()
12263 
      if ftype == TType.STOP:
12264 
        break
12265 
      if fid == 0:
3064 chandransh 12266 
        if ftype == TType.BOOL:
12267 
          self.success = iprot.readBool();
1113 chandransh 12268 
        else:
12269 
          iprot.skip(ftype)
12270 
      elif fid == 1:
12271 
        if ftype == TType.STRUCT:
12272 
          self.ex = TransactionServiceException()
12273 
          self.ex.read(iprot)
12274 
        else:
12275 
          iprot.skip(ftype)
12276 
      else:
12277 
        iprot.skip(ftype)
12278 
      iprot.readFieldEnd()
12279 
    iprot.readStructEnd()
12280 
 
12281 
  def write(self, oprot):
12282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12284 
      return
3064 chandransh 12285 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 12286 
    if self.success is not None:
3064 chandransh 12287 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12288 
      oprot.writeBool(self.success)
1113 chandransh 12289 
      oprot.writeFieldEnd()
3431 rajveer 12290 
    if self.ex is not None:
1113 chandransh 12291 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12292 
      self.ex.write(oprot)
12293 
      oprot.writeFieldEnd()
12294 
    oprot.writeFieldStop()
12295 
    oprot.writeStructEnd()
12296 
 
3431 rajveer 12297 
  def validate(self):
12298 
    return
12299 
 
12300 
 
1113 chandransh 12301 
  def __repr__(self):
12302 
    L = ['%s=%r' % (key, value)
12303 
      for key, value in self.__dict__.iteritems()]
12304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12305 
 
12306 
  def __eq__(self, other):
12307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12308 
 
12309 
  def __ne__(self, other):
12310 
    return not (self == other)
12311 
 
3064 chandransh 12312 
class addBillingDetails_args:
1135 chandransh 12313 
  """
12314 
  Attributes:
3064 chandransh 12315 
   - orderId
12316 
   - invoice_number
4658 mandeep.dh 12317 
   - serialNumber
4283 anupam.sin 12318 
   - itemNumber
3064 chandransh 12319 
   - billed_by
4264 rajveer 12320 
   - jacketNumber
4283 anupam.sin 12321 
   - billingType
5110 mandeep.dh 12322 
   - fulfilmentWarehouseId
4763 rajveer 12323 
   - authorize
1135 chandransh 12324 
  """
12325 
 
12326 
  thrift_spec = (
12327 
    None, # 0
3064 chandransh 12328 
    (1, TType.I64, 'orderId', None, None, ), # 1
12329 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 12330 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
12331 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 12332 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
12333 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
12334 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 12335 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 12336 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 12337 
  )
12338 
 
5110 mandeep.dh 12339 
  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 12340 
    self.orderId = orderId
12341 
    self.invoice_number = invoice_number
4658 mandeep.dh 12342 
    self.serialNumber = serialNumber
4283 anupam.sin 12343 
    self.itemNumber = itemNumber
3064 chandransh 12344 
    self.billed_by = billed_by
4264 rajveer 12345 
    self.jacketNumber = jacketNumber
4283 anupam.sin 12346 
    self.billingType = billingType
5110 mandeep.dh 12347 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 12348 
    self.authorize = authorize
1135 chandransh 12349 
 
12350 
  def read(self, iprot):
12351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12353 
      return
12354 
    iprot.readStructBegin()
12355 
    while True:
12356 
      (fname, ftype, fid) = iprot.readFieldBegin()
12357 
      if ftype == TType.STOP:
12358 
        break
12359 
      if fid == 1:
12360 
        if ftype == TType.I64:
3064 chandransh 12361 
          self.orderId = iprot.readI64();
1135 chandransh 12362 
        else:
12363 
          iprot.skip(ftype)
12364 
      elif fid == 2:
3064 chandransh 12365 
        if ftype == TType.STRING:
12366 
          self.invoice_number = iprot.readString();
1135 chandransh 12367 
        else:
12368 
          iprot.skip(ftype)
3064 chandransh 12369 
      elif fid == 3:
5411 rajveer 12370 
        if ftype == TType.LIST:
12371 
          self.serialNumber = []
12372 
          (_etype227, _size224) = iprot.readListBegin()
12373 
          for _i228 in xrange(_size224):
12374 
            _elem229 = iprot.readString();
12375 
            self.serialNumber.append(_elem229)
12376 
          iprot.readListEnd()
3064 chandransh 12377 
        else:
12378 
          iprot.skip(ftype)
12379 
      elif fid == 4:
5411 rajveer 12380 
        if ftype == TType.LIST:
12381 
          self.itemNumber = []
12382 
          (_etype233, _size230) = iprot.readListBegin()
12383 
          for _i234 in xrange(_size230):
12384 
            _elem235 = iprot.readString();
12385 
            self.itemNumber.append(_elem235)
12386 
          iprot.readListEnd()
3064 chandransh 12387 
        else:
12388 
          iprot.skip(ftype)
12389 
      elif fid == 5:
12390 
        if ftype == TType.STRING:
4283 anupam.sin 12391 
          self.billed_by = iprot.readString();
3064 chandransh 12392 
        else:
12393 
          iprot.skip(ftype)
12394 
      elif fid == 6:
12395 
        if ftype == TType.I64:
4283 anupam.sin 12396 
          self.jacketNumber = iprot.readI64();
12397 
        else:
12398 
          iprot.skip(ftype)
12399 
      elif fid == 7:
12400 
        if ftype == TType.I64:
3064 chandransh 12401 
          self.billingType = iprot.readI64();
12402 
        else:
12403 
          iprot.skip(ftype)
4283 anupam.sin 12404 
      elif fid == 8:
12405 
        if ftype == TType.I64:
5110 mandeep.dh 12406 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 12407 
        else:
12408 
          iprot.skip(ftype)
4763 rajveer 12409 
      elif fid == 9:
12410 
        if ftype == TType.BOOL:
12411 
          self.authorize = iprot.readBool();
12412 
        else:
12413 
          iprot.skip(ftype)
1246 chandransh 12414 
      else:
12415 
        iprot.skip(ftype)
12416 
      iprot.readFieldEnd()
12417 
    iprot.readStructEnd()
12418 
 
12419 
  def write(self, oprot):
12420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12422 
      return
4283 anupam.sin 12423 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 12424 
    if self.orderId is not None:
3064 chandransh 12425 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12426 
      oprot.writeI64(self.orderId)
1246 chandransh 12427 
      oprot.writeFieldEnd()
4283 anupam.sin 12428 
    if self.invoice_number is not None:
12429 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
12430 
      oprot.writeString(self.invoice_number)
1246 chandransh 12431 
      oprot.writeFieldEnd()
4658 mandeep.dh 12432 
    if self.serialNumber is not None:
5411 rajveer 12433 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
12434 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
12435 
      for iter236 in self.serialNumber:
12436 
        oprot.writeString(iter236)
12437 
      oprot.writeListEnd()
3064 chandransh 12438 
      oprot.writeFieldEnd()
3431 rajveer 12439 
    if self.itemNumber is not None:
5411 rajveer 12440 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
12441 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
12442 
      for iter237 in self.itemNumber:
12443 
        oprot.writeString(iter237)
12444 
      oprot.writeListEnd()
3064 chandransh 12445 
      oprot.writeFieldEnd()
4283 anupam.sin 12446 
    if self.billed_by is not None:
12447 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
12448 
      oprot.writeString(self.billed_by)
3064 chandransh 12449 
      oprot.writeFieldEnd()
4283 anupam.sin 12450 
    if self.jacketNumber is not None:
12451 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
12452 
      oprot.writeI64(self.jacketNumber)
12453 
      oprot.writeFieldEnd()
3431 rajveer 12454 
    if self.billingType is not None:
4283 anupam.sin 12455 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 12456 
      oprot.writeI64(self.billingType)
12457 
      oprot.writeFieldEnd()
5110 mandeep.dh 12458 
    if self.fulfilmentWarehouseId is not None:
12459 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
12460 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 12461 
      oprot.writeFieldEnd()
4763 rajveer 12462 
    if self.authorize is not None:
12463 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
12464 
      oprot.writeBool(self.authorize)
12465 
      oprot.writeFieldEnd()
1246 chandransh 12466 
    oprot.writeFieldStop()
12467 
    oprot.writeStructEnd()
12468 
 
3431 rajveer 12469 
  def validate(self):
12470 
    return
12471 
 
12472 
 
1246 chandransh 12473 
  def __repr__(self):
12474 
    L = ['%s=%r' % (key, value)
12475 
      for key, value in self.__dict__.iteritems()]
12476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12477 
 
12478 
  def __eq__(self, other):
12479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12480 
 
12481 
  def __ne__(self, other):
12482 
    return not (self == other)
12483 
 
4283 anupam.sin 12484 
class addBillingDetails_result:
1246 chandransh 12485 
  """
12486 
  Attributes:
3064 chandransh 12487 
   - success
1246 chandransh 12488 
   - ex
12489 
  """
12490 
 
12491 
  thrift_spec = (
3064 chandransh 12492 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 12493 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12494 
  )
12495 
 
3064 chandransh 12496 
  def __init__(self, success=None, ex=None,):
12497 
    self.success = success
1246 chandransh 12498 
    self.ex = ex
12499 
 
12500 
  def read(self, iprot):
12501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12503 
      return
12504 
    iprot.readStructBegin()
12505 
    while True:
12506 
      (fname, ftype, fid) = iprot.readFieldBegin()
12507 
      if ftype == TType.STOP:
12508 
        break
3064 chandransh 12509 
      if fid == 0:
12510 
        if ftype == TType.BOOL:
12511 
          self.success = iprot.readBool();
12512 
        else:
12513 
          iprot.skip(ftype)
12514 
      elif fid == 1:
1246 chandransh 12515 
        if ftype == TType.STRUCT:
12516 
          self.ex = TransactionServiceException()
12517 
          self.ex.read(iprot)
12518 
        else:
12519 
          iprot.skip(ftype)
12520 
      else:
12521 
        iprot.skip(ftype)
12522 
      iprot.readFieldEnd()
12523 
    iprot.readStructEnd()
12524 
 
12525 
  def write(self, oprot):
12526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12528 
      return
4283 anupam.sin 12529 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 12530 
    if self.success is not None:
3064 chandransh 12531 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12532 
      oprot.writeBool(self.success)
12533 
      oprot.writeFieldEnd()
3431 rajveer 12534 
    if self.ex is not None:
1246 chandransh 12535 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12536 
      self.ex.write(oprot)
12537 
      oprot.writeFieldEnd()
12538 
    oprot.writeFieldStop()
12539 
    oprot.writeStructEnd()
12540 
 
3431 rajveer 12541 
  def validate(self):
12542 
    return
12543 
 
12544 
 
1246 chandransh 12545 
  def __repr__(self):
12546 
    L = ['%s=%r' % (key, value)
12547 
      for key, value in self.__dict__.iteritems()]
12548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12549 
 
12550 
  def __eq__(self, other):
12551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12552 
 
12553 
  def __ne__(self, other):
12554 
    return not (self == other)
12555 
 
4579 rajveer 12556 
class addInvoiceNumber_args:
12557 
  """
12558 
  Attributes:
12559 
   - orderId
12560 
   - invoiceNumber
4763 rajveer 12561 
   - color
4579 rajveer 12562 
  """
12563 
 
12564 
  thrift_spec = (
12565 
    None, # 0
12566 
    (1, TType.I64, 'orderId', None, None, ), # 1
12567 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 12568 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 12569 
  )
12570 
 
4763 rajveer 12571 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 12572 
    self.orderId = orderId
12573 
    self.invoiceNumber = invoiceNumber
4763 rajveer 12574 
    self.color = color
4579 rajveer 12575 
 
12576 
  def read(self, iprot):
12577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12579 
      return
12580 
    iprot.readStructBegin()
12581 
    while True:
12582 
      (fname, ftype, fid) = iprot.readFieldBegin()
12583 
      if ftype == TType.STOP:
12584 
        break
12585 
      if fid == 1:
12586 
        if ftype == TType.I64:
12587 
          self.orderId = iprot.readI64();
12588 
        else:
12589 
          iprot.skip(ftype)
12590 
      elif fid == 2:
12591 
        if ftype == TType.STRING:
12592 
          self.invoiceNumber = iprot.readString();
12593 
        else:
12594 
          iprot.skip(ftype)
4763 rajveer 12595 
      elif fid == 3:
12596 
        if ftype == TType.STRING:
12597 
          self.color = iprot.readString();
12598 
        else:
12599 
          iprot.skip(ftype)
4579 rajveer 12600 
      else:
12601 
        iprot.skip(ftype)
12602 
      iprot.readFieldEnd()
12603 
    iprot.readStructEnd()
12604 
 
12605 
  def write(self, oprot):
12606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12608 
      return
12609 
    oprot.writeStructBegin('addInvoiceNumber_args')
12610 
    if self.orderId is not None:
12611 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12612 
      oprot.writeI64(self.orderId)
12613 
      oprot.writeFieldEnd()
12614 
    if self.invoiceNumber is not None:
12615 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
12616 
      oprot.writeString(self.invoiceNumber)
12617 
      oprot.writeFieldEnd()
4763 rajveer 12618 
    if self.color is not None:
12619 
      oprot.writeFieldBegin('color', TType.STRING, 3)
12620 
      oprot.writeString(self.color)
12621 
      oprot.writeFieldEnd()
4579 rajveer 12622 
    oprot.writeFieldStop()
12623 
    oprot.writeStructEnd()
12624 
 
12625 
  def validate(self):
12626 
    return
12627 
 
12628 
 
12629 
  def __repr__(self):
12630 
    L = ['%s=%r' % (key, value)
12631 
      for key, value in self.__dict__.iteritems()]
12632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12633 
 
12634 
  def __eq__(self, other):
12635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12636 
 
12637 
  def __ne__(self, other):
12638 
    return not (self == other)
12639 
 
12640 
class addInvoiceNumber_result:
12641 
  """
12642 
  Attributes:
12643 
   - ex
12644 
  """
12645 
 
12646 
  thrift_spec = (
12647 
    None, # 0
12648 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12649 
  )
12650 
 
12651 
  def __init__(self, ex=None,):
12652 
    self.ex = ex
12653 
 
12654 
  def read(self, iprot):
12655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12657 
      return
12658 
    iprot.readStructBegin()
12659 
    while True:
12660 
      (fname, ftype, fid) = iprot.readFieldBegin()
12661 
      if ftype == TType.STOP:
12662 
        break
12663 
      if fid == 1:
12664 
        if ftype == TType.STRUCT:
12665 
          self.ex = TransactionServiceException()
12666 
          self.ex.read(iprot)
12667 
        else:
12668 
          iprot.skip(ftype)
12669 
      else:
12670 
        iprot.skip(ftype)
12671 
      iprot.readFieldEnd()
12672 
    iprot.readStructEnd()
12673 
 
12674 
  def write(self, oprot):
12675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12677 
      return
12678 
    oprot.writeStructBegin('addInvoiceNumber_result')
12679 
    if self.ex is not None:
12680 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12681 
      self.ex.write(oprot)
12682 
      oprot.writeFieldEnd()
12683 
    oprot.writeFieldStop()
12684 
    oprot.writeStructEnd()
12685 
 
12686 
  def validate(self):
12687 
    return
12688 
 
12689 
 
12690 
  def __repr__(self):
12691 
    L = ['%s=%r' % (key, value)
12692 
      for key, value in self.__dict__.iteritems()]
12693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12694 
 
12695 
  def __eq__(self, other):
12696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12697 
 
12698 
  def __ne__(self, other):
12699 
    return not (self == other)
12700 
 
4910 phani.kuma 12701 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 12702 
  """
12703 
  Attributes:
3064 chandransh 12704 
   - warehouseId
1408 ankur.sing 12705 
   - providerId
3064 chandransh 12706 
   - cod
4910 phani.kuma 12707 
   - orderIds
1408 ankur.sing 12708 
  """
12709 
 
12710 
  thrift_spec = (
12711 
    None, # 0
3064 chandransh 12712 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12713 
    (2, TType.I64, 'providerId', None, None, ), # 2
12714 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 12715 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 12716 
  )
12717 
 
4910 phani.kuma 12718 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 12719 
    self.warehouseId = warehouseId
1408 ankur.sing 12720 
    self.providerId = providerId
3064 chandransh 12721 
    self.cod = cod
4910 phani.kuma 12722 
    self.orderIds = orderIds
1408 ankur.sing 12723 
 
12724 
  def read(self, iprot):
12725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12727 
      return
12728 
    iprot.readStructBegin()
12729 
    while True:
12730 
      (fname, ftype, fid) = iprot.readFieldBegin()
12731 
      if ftype == TType.STOP:
12732 
        break
12733 
      if fid == 1:
12734 
        if ftype == TType.I64:
3064 chandransh 12735 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 12736 
        else:
12737 
          iprot.skip(ftype)
12738 
      elif fid == 2:
12739 
        if ftype == TType.I64:
3064 chandransh 12740 
          self.providerId = iprot.readI64();
1408 ankur.sing 12741 
        else:
12742 
          iprot.skip(ftype)
3064 chandransh 12743 
      elif fid == 3:
12744 
        if ftype == TType.BOOL:
12745 
          self.cod = iprot.readBool();
12746 
        else:
12747 
          iprot.skip(ftype)
4910 phani.kuma 12748 
      elif fid == 4:
12749 
        if ftype == TType.LIST:
12750 
          self.orderIds = []
5411 rajveer 12751 
          (_etype241, _size238) = iprot.readListBegin()
12752 
          for _i242 in xrange(_size238):
12753 
            _elem243 = iprot.readI64();
12754 
            self.orderIds.append(_elem243)
4910 phani.kuma 12755 
          iprot.readListEnd()
12756 
        else:
12757 
          iprot.skip(ftype)
1408 ankur.sing 12758 
      else:
12759 
        iprot.skip(ftype)
12760 
      iprot.readFieldEnd()
12761 
    iprot.readStructEnd()
12762 
 
12763 
  def write(self, oprot):
12764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12766 
      return
4910 phani.kuma 12767 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 12768 
    if self.warehouseId is not None:
3064 chandransh 12769 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12770 
      oprot.writeI64(self.warehouseId)
12771 
      oprot.writeFieldEnd()
3431 rajveer 12772 
    if self.providerId is not None:
3064 chandransh 12773 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 12774 
      oprot.writeI64(self.providerId)
12775 
      oprot.writeFieldEnd()
3431 rajveer 12776 
    if self.cod is not None:
3064 chandransh 12777 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
12778 
      oprot.writeBool(self.cod)
1408 ankur.sing 12779 
      oprot.writeFieldEnd()
4910 phani.kuma 12780 
    if self.orderIds is not None:
12781 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
12782 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5411 rajveer 12783 
      for iter244 in self.orderIds:
12784 
        oprot.writeI64(iter244)
4910 phani.kuma 12785 
      oprot.writeListEnd()
12786 
      oprot.writeFieldEnd()
1408 ankur.sing 12787 
    oprot.writeFieldStop()
12788 
    oprot.writeStructEnd()
12789 
 
3431 rajveer 12790 
  def validate(self):
12791 
    return
12792 
 
12793 
 
1408 ankur.sing 12794 
  def __repr__(self):
12795 
    L = ['%s=%r' % (key, value)
12796 
      for key, value in self.__dict__.iteritems()]
12797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12798 
 
12799 
  def __eq__(self, other):
12800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12801 
 
12802 
  def __ne__(self, other):
12803 
    return not (self == other)
12804 
 
4910 phani.kuma 12805 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 12806 
  """
12807 
  Attributes:
12808 
   - success
3064 chandransh 12809 
   - ex
1408 ankur.sing 12810 
  """
12811 
 
12812 
  thrift_spec = (
3064 chandransh 12813 
    (0, TType.BOOL, 'success', None, None, ), # 0
12814 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 12815 
  )
12816 
 
3064 chandransh 12817 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 12818 
    self.success = success
3064 chandransh 12819 
    self.ex = ex
1408 ankur.sing 12820 
 
12821 
  def read(self, iprot):
12822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12824 
      return
12825 
    iprot.readStructBegin()
12826 
    while True:
12827 
      (fname, ftype, fid) = iprot.readFieldBegin()
12828 
      if ftype == TType.STOP:
12829 
        break
12830 
      if fid == 0:
3064 chandransh 12831 
        if ftype == TType.BOOL:
12832 
          self.success = iprot.readBool();
1408 ankur.sing 12833 
        else:
12834 
          iprot.skip(ftype)
3064 chandransh 12835 
      elif fid == 1:
12836 
        if ftype == TType.STRUCT:
12837 
          self.ex = TransactionServiceException()
12838 
          self.ex.read(iprot)
12839 
        else:
12840 
          iprot.skip(ftype)
1408 ankur.sing 12841 
      else:
12842 
        iprot.skip(ftype)
12843 
      iprot.readFieldEnd()
12844 
    iprot.readStructEnd()
12845 
 
12846 
  def write(self, oprot):
12847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12849 
      return
4910 phani.kuma 12850 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 12851 
    if self.success is not None:
3064 chandransh 12852 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12853 
      oprot.writeBool(self.success)
1408 ankur.sing 12854 
      oprot.writeFieldEnd()
3431 rajveer 12855 
    if self.ex is not None:
3064 chandransh 12856 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12857 
      self.ex.write(oprot)
12858 
      oprot.writeFieldEnd()
1408 ankur.sing 12859 
    oprot.writeFieldStop()
12860 
    oprot.writeStructEnd()
12861 
 
3431 rajveer 12862 
  def validate(self):
12863 
    return
12864 
 
12865 
 
1408 ankur.sing 12866 
  def __repr__(self):
12867 
    L = ['%s=%r' % (key, value)
12868 
      for key, value in self.__dict__.iteritems()]
12869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12870 
 
12871 
  def __eq__(self, other):
12872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12873 
 
12874 
  def __ne__(self, other):
12875 
    return not (self == other)
12876 
 
5676 rajveer 12877 
class markOrdersAsReturnedFromStore_args:
12878 
  """
12879 
  Attributes:
12880 
   - providerId
12881 
   - orderIds
5713 rajveer 12882 
   - awbs
5676 rajveer 12883 
  """
12884 
 
12885 
  thrift_spec = (
12886 
    None, # 0
12887 
    (1, TType.I64, 'providerId', None, None, ), # 1
12888 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 12889 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 12890 
  )
12891 
 
5713 rajveer 12892 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 12893 
    self.providerId = providerId
12894 
    self.orderIds = orderIds
5713 rajveer 12895 
    self.awbs = awbs
5676 rajveer 12896 
 
12897 
  def read(self, iprot):
12898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12900 
      return
12901 
    iprot.readStructBegin()
12902 
    while True:
12903 
      (fname, ftype, fid) = iprot.readFieldBegin()
12904 
      if ftype == TType.STOP:
12905 
        break
12906 
      if fid == 1:
12907 
        if ftype == TType.I64:
12908 
          self.providerId = iprot.readI64();
12909 
        else:
12910 
          iprot.skip(ftype)
12911 
      elif fid == 2:
12912 
        if ftype == TType.LIST:
12913 
          self.orderIds = []
12914 
          (_etype248, _size245) = iprot.readListBegin()
12915 
          for _i249 in xrange(_size245):
12916 
            _elem250 = iprot.readI64();
12917 
            self.orderIds.append(_elem250)
12918 
          iprot.readListEnd()
12919 
        else:
12920 
          iprot.skip(ftype)
5713 rajveer 12921 
      elif fid == 3:
12922 
        if ftype == TType.LIST:
12923 
          self.awbs = []
12924 
          (_etype254, _size251) = iprot.readListBegin()
12925 
          for _i255 in xrange(_size251):
12926 
            _elem256 = iprot.readString();
12927 
            self.awbs.append(_elem256)
12928 
          iprot.readListEnd()
12929 
        else:
12930 
          iprot.skip(ftype)
5676 rajveer 12931 
      else:
12932 
        iprot.skip(ftype)
12933 
      iprot.readFieldEnd()
12934 
    iprot.readStructEnd()
12935 
 
12936 
  def write(self, oprot):
12937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12939 
      return
12940 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
12941 
    if self.providerId is not None:
12942 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
12943 
      oprot.writeI64(self.providerId)
12944 
      oprot.writeFieldEnd()
12945 
    if self.orderIds is not None:
12946 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
12947 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5713 rajveer 12948 
      for iter257 in self.orderIds:
12949 
        oprot.writeI64(iter257)
5676 rajveer 12950 
      oprot.writeListEnd()
12951 
      oprot.writeFieldEnd()
5713 rajveer 12952 
    if self.awbs is not None:
12953 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
12954 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
12955 
      for iter258 in self.awbs:
12956 
        oprot.writeString(iter258)
12957 
      oprot.writeListEnd()
12958 
      oprot.writeFieldEnd()
5676 rajveer 12959 
    oprot.writeFieldStop()
12960 
    oprot.writeStructEnd()
12961 
 
12962 
  def validate(self):
12963 
    return
12964 
 
12965 
 
12966 
  def __repr__(self):
12967 
    L = ['%s=%r' % (key, value)
12968 
      for key, value in self.__dict__.iteritems()]
12969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12970 
 
12971 
  def __eq__(self, other):
12972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12973 
 
12974 
  def __ne__(self, other):
12975 
    return not (self == other)
12976 
 
12977 
class markOrdersAsReturnedFromStore_result:
12978 
  """
12979 
  Attributes:
12980 
   - success
12981 
   - ex
12982 
  """
12983 
 
12984 
  thrift_spec = (
12985 
    (0, TType.BOOL, 'success', None, None, ), # 0
12986 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12987 
  )
12988 
 
12989 
  def __init__(self, success=None, ex=None,):
12990 
    self.success = success
12991 
    self.ex = ex
12992 
 
12993 
  def read(self, iprot):
12994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12996 
      return
12997 
    iprot.readStructBegin()
12998 
    while True:
12999 
      (fname, ftype, fid) = iprot.readFieldBegin()
13000 
      if ftype == TType.STOP:
13001 
        break
13002 
      if fid == 0:
13003 
        if ftype == TType.BOOL:
13004 
          self.success = iprot.readBool();
13005 
        else:
13006 
          iprot.skip(ftype)
13007 
      elif fid == 1:
13008 
        if ftype == TType.STRUCT:
13009 
          self.ex = TransactionServiceException()
13010 
          self.ex.read(iprot)
13011 
        else:
13012 
          iprot.skip(ftype)
13013 
      else:
13014 
        iprot.skip(ftype)
13015 
      iprot.readFieldEnd()
13016 
    iprot.readStructEnd()
13017 
 
13018 
  def write(self, oprot):
13019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13021 
      return
13022 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
13023 
    if self.success is not None:
13024 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13025 
      oprot.writeBool(self.success)
13026 
      oprot.writeFieldEnd()
13027 
    if self.ex is not None:
13028 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13029 
      self.ex.write(oprot)
13030 
      oprot.writeFieldEnd()
13031 
    oprot.writeFieldStop()
13032 
    oprot.writeStructEnd()
13033 
 
13034 
  def validate(self):
13035 
    return
13036 
 
13037 
 
13038 
  def __repr__(self):
13039 
    L = ['%s=%r' % (key, value)
13040 
      for key, value in self.__dict__.iteritems()]
13041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13042 
 
13043 
  def __eq__(self, other):
13044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13045 
 
13046 
  def __ne__(self, other):
13047 
    return not (self == other)
13048 
 
4910 phani.kuma 13049 
class markOrdersAsPickedUp_args:
4410 rajveer 13050 
  """
13051 
  Attributes:
13052 
   - providerId
4910 phani.kuma 13053 
   - pickupDetails
4410 rajveer 13054 
  """
13055 
 
13056 
  thrift_spec = (
13057 
    None, # 0
4910 phani.kuma 13058 
    (1, TType.I64, 'providerId', None, None, ), # 1
13059 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 13060 
  )
13061 
 
4910 phani.kuma 13062 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 13063 
    self.providerId = providerId
4910 phani.kuma 13064 
    self.pickupDetails = pickupDetails
4410 rajveer 13065 
 
13066 
  def read(self, iprot):
13067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13069 
      return
13070 
    iprot.readStructBegin()
13071 
    while True:
13072 
      (fname, ftype, fid) = iprot.readFieldBegin()
13073 
      if ftype == TType.STOP:
13074 
        break
13075 
      if fid == 1:
13076 
        if ftype == TType.I64:
4910 phani.kuma 13077 
          self.providerId = iprot.readI64();
4410 rajveer 13078 
        else:
13079 
          iprot.skip(ftype)
13080 
      elif fid == 2:
4910 phani.kuma 13081 
        if ftype == TType.MAP:
13082 
          self.pickupDetails = {}
5713 rajveer 13083 
          (_ktype260, _vtype261, _size259 ) = iprot.readMapBegin()
13084 
          for _i263 in xrange(_size259):
13085 
            _key264 = iprot.readString();
13086 
            _val265 = iprot.readString();
13087 
            self.pickupDetails[_key264] = _val265
4910 phani.kuma 13088 
          iprot.readMapEnd()
4410 rajveer 13089 
        else:
13090 
          iprot.skip(ftype)
13091 
      else:
13092 
        iprot.skip(ftype)
13093 
      iprot.readFieldEnd()
13094 
    iprot.readStructEnd()
13095 
 
13096 
  def write(self, oprot):
13097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13099 
      return
4910 phani.kuma 13100 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 13101 
    if self.providerId is not None:
4910 phani.kuma 13102 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 13103 
      oprot.writeI64(self.providerId)
13104 
      oprot.writeFieldEnd()
4910 phani.kuma 13105 
    if self.pickupDetails is not None:
13106 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13107 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5713 rajveer 13108 
      for kiter266,viter267 in self.pickupDetails.items():
13109 
        oprot.writeString(kiter266)
13110 
        oprot.writeString(viter267)
4910 phani.kuma 13111 
      oprot.writeMapEnd()
4410 rajveer 13112 
      oprot.writeFieldEnd()
13113 
    oprot.writeFieldStop()
13114 
    oprot.writeStructEnd()
13115 
 
13116 
  def validate(self):
13117 
    return
13118 
 
13119 
 
13120 
  def __repr__(self):
13121 
    L = ['%s=%r' % (key, value)
13122 
      for key, value in self.__dict__.iteritems()]
13123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13124 
 
13125 
  def __eq__(self, other):
13126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13127 
 
13128 
  def __ne__(self, other):
13129 
    return not (self == other)
13130 
 
4910 phani.kuma 13131 
class markOrdersAsPickedUp_result:
4410 rajveer 13132 
  """
13133 
  Attributes:
13134 
   - ex
13135 
  """
13136 
 
13137 
  thrift_spec = (
4910 phani.kuma 13138 
    None, # 0
4410 rajveer 13139 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13140 
  )
13141 
 
4910 phani.kuma 13142 
  def __init__(self, ex=None,):
4410 rajveer 13143 
    self.ex = ex
13144 
 
13145 
  def read(self, iprot):
13146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13148 
      return
13149 
    iprot.readStructBegin()
13150 
    while True:
13151 
      (fname, ftype, fid) = iprot.readFieldBegin()
13152 
      if ftype == TType.STOP:
13153 
        break
4910 phani.kuma 13154 
      if fid == 1:
4410 rajveer 13155 
        if ftype == TType.STRUCT:
13156 
          self.ex = TransactionServiceException()
13157 
          self.ex.read(iprot)
13158 
        else:
13159 
          iprot.skip(ftype)
13160 
      else:
13161 
        iprot.skip(ftype)
13162 
      iprot.readFieldEnd()
13163 
    iprot.readStructEnd()
13164 
 
13165 
  def write(self, oprot):
13166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13168 
      return
4910 phani.kuma 13169 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 13170 
    if self.ex is not None:
13171 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13172 
      self.ex.write(oprot)
13173 
      oprot.writeFieldEnd()
13174 
    oprot.writeFieldStop()
13175 
    oprot.writeStructEnd()
13176 
 
13177 
  def validate(self):
13178 
    return
13179 
 
13180 
 
13181 
  def __repr__(self):
13182 
    L = ['%s=%r' % (key, value)
13183 
      for key, value in self.__dict__.iteritems()]
13184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13185 
 
13186 
  def __eq__(self, other):
13187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13188 
 
13189 
  def __ne__(self, other):
13190 
    return not (self == other)
13191 
 
4910 phani.kuma 13192 
class getOrdersNotPickedUp_args:
304 ashish 13193 
  """
13194 
  Attributes:
3064 chandransh 13195 
   - providerId
304 ashish 13196 
  """
94 ashish 13197 
 
304 ashish 13198 
  thrift_spec = (
13199 
    None, # 0
3064 chandransh 13200 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 13201 
  )
13202 
 
4910 phani.kuma 13203 
  def __init__(self, providerId=None,):
3064 chandransh 13204 
    self.providerId = providerId
304 ashish 13205 
 
13206 
  def read(self, iprot):
13207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13209 
      return
13210 
    iprot.readStructBegin()
13211 
    while True:
13212 
      (fname, ftype, fid) = iprot.readFieldBegin()
13213 
      if ftype == TType.STOP:
13214 
        break
13215 
      if fid == 1:
13216 
        if ftype == TType.I64:
3064 chandransh 13217 
          self.providerId = iprot.readI64();
304 ashish 13218 
        else:
13219 
          iprot.skip(ftype)
13220 
      else:
13221 
        iprot.skip(ftype)
13222 
      iprot.readFieldEnd()
13223 
    iprot.readStructEnd()
13224 
 
13225 
  def write(self, oprot):
13226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13228 
      return
4910 phani.kuma 13229 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 13230 
    if self.providerId is not None:
3064 chandransh 13231 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13232 
      oprot.writeI64(self.providerId)
304 ashish 13233 
      oprot.writeFieldEnd()
13234 
    oprot.writeFieldStop()
13235 
    oprot.writeStructEnd()
13236 
 
3431 rajveer 13237 
  def validate(self):
13238 
    return
13239 
 
13240 
 
304 ashish 13241 
  def __repr__(self):
13242 
    L = ['%s=%r' % (key, value)
13243 
      for key, value in self.__dict__.iteritems()]
13244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13245 
 
13246 
  def __eq__(self, other):
13247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13248 
 
13249 
  def __ne__(self, other):
13250 
    return not (self == other)
13251 
 
4910 phani.kuma 13252 
class getOrdersNotPickedUp_result:
304 ashish 13253 
  """
13254 
  Attributes:
13255 
   - success
13256 
  """
13257 
 
13258 
  thrift_spec = (
3064 chandransh 13259 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 13260 
  )
13261 
 
4910 phani.kuma 13262 
  def __init__(self, success=None,):
304 ashish 13263 
    self.success = success
13264 
 
13265 
  def read(self, iprot):
13266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13268 
      return
13269 
    iprot.readStructBegin()
13270 
    while True:
13271 
      (fname, ftype, fid) = iprot.readFieldBegin()
13272 
      if ftype == TType.STOP:
13273 
        break
13274 
      if fid == 0:
13275 
        if ftype == TType.LIST:
13276 
          self.success = []
5713 rajveer 13277 
          (_etype271, _size268) = iprot.readListBegin()
13278 
          for _i272 in xrange(_size268):
13279 
            _elem273 = Order()
13280 
            _elem273.read(iprot)
13281 
            self.success.append(_elem273)
304 ashish 13282 
          iprot.readListEnd()
13283 
        else:
13284 
          iprot.skip(ftype)
13285 
      else:
13286 
        iprot.skip(ftype)
13287 
      iprot.readFieldEnd()
13288 
    iprot.readStructEnd()
13289 
 
13290 
  def write(self, oprot):
13291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13293 
      return
4910 phani.kuma 13294 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 13295 
    if self.success is not None:
304 ashish 13296 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13297 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 13298 
      for iter274 in self.success:
13299 
        iter274.write(oprot)
304 ashish 13300 
      oprot.writeListEnd()
13301 
      oprot.writeFieldEnd()
13302 
    oprot.writeFieldStop()
13303 
    oprot.writeStructEnd()
13304 
 
3431 rajveer 13305 
  def validate(self):
13306 
    return
13307 
 
13308 
 
304 ashish 13309 
  def __repr__(self):
13310 
    L = ['%s=%r' % (key, value)
13311 
      for key, value in self.__dict__.iteritems()]
13312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13313 
 
13314 
  def __eq__(self, other):
13315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13316 
 
13317 
  def __ne__(self, other):
13318 
    return not (self == other)
13319 
 
3064 chandransh 13320 
class markOrdersAsDelivered_args:
304 ashish 13321 
  """
13322 
  Attributes:
3064 chandransh 13323 
   - providerId
13324 
   - deliveredOrders
304 ashish 13325 
  """
13326 
 
13327 
  thrift_spec = (
13328 
    None, # 0
3064 chandransh 13329 
    (1, TType.I64, 'providerId', None, None, ), # 1
13330 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 13331 
  )
13332 
 
3064 chandransh 13333 
  def __init__(self, providerId=None, deliveredOrders=None,):
13334 
    self.providerId = providerId
13335 
    self.deliveredOrders = deliveredOrders
304 ashish 13336 
 
13337 
  def read(self, iprot):
13338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13340 
      return
13341 
    iprot.readStructBegin()
13342 
    while True:
13343 
      (fname, ftype, fid) = iprot.readFieldBegin()
13344 
      if ftype == TType.STOP:
13345 
        break
13346 
      if fid == 1:
13347 
        if ftype == TType.I64:
3064 chandransh 13348 
          self.providerId = iprot.readI64();
304 ashish 13349 
        else:
13350 
          iprot.skip(ftype)
13351 
      elif fid == 2:
3064 chandransh 13352 
        if ftype == TType.MAP:
13353 
          self.deliveredOrders = {}
5713 rajveer 13354 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
13355 
          for _i279 in xrange(_size275):
13356 
            _key280 = iprot.readString();
13357 
            _val281 = iprot.readString();
13358 
            self.deliveredOrders[_key280] = _val281
3064 chandransh 13359 
          iprot.readMapEnd()
304 ashish 13360 
        else:
13361 
          iprot.skip(ftype)
13362 
      else:
13363 
        iprot.skip(ftype)
13364 
      iprot.readFieldEnd()
13365 
    iprot.readStructEnd()
13366 
 
13367 
  def write(self, oprot):
13368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13370 
      return
3064 chandransh 13371 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 13372 
    if self.providerId is not None:
3064 chandransh 13373 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13374 
      oprot.writeI64(self.providerId)
304 ashish 13375 
      oprot.writeFieldEnd()
3431 rajveer 13376 
    if self.deliveredOrders is not None:
3064 chandransh 13377 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
13378 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
5713 rajveer 13379 
      for kiter282,viter283 in self.deliveredOrders.items():
13380 
        oprot.writeString(kiter282)
13381 
        oprot.writeString(viter283)
3064 chandransh 13382 
      oprot.writeMapEnd()
304 ashish 13383 
      oprot.writeFieldEnd()
13384 
    oprot.writeFieldStop()
13385 
    oprot.writeStructEnd()
13386 
 
3431 rajveer 13387 
  def validate(self):
13388 
    return
13389 
 
13390 
 
304 ashish 13391 
  def __repr__(self):
13392 
    L = ['%s=%r' % (key, value)
13393 
      for key, value in self.__dict__.iteritems()]
13394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13395 
 
13396 
  def __eq__(self, other):
13397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13398 
 
13399 
  def __ne__(self, other):
13400 
    return not (self == other)
13401 
 
3064 chandransh 13402 
class markOrdersAsDelivered_result:
13403 
  """
13404 
  Attributes:
13405 
   - ex
13406 
  """
304 ashish 13407 
 
13408 
  thrift_spec = (
3064 chandransh 13409 
    None, # 0
13410 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 13411 
  )
13412 
 
3064 chandransh 13413 
  def __init__(self, ex=None,):
13414 
    self.ex = ex
304 ashish 13415 
 
1596 ankur.sing 13416 
  def read(self, iprot):
13417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13419 
      return
13420 
    iprot.readStructBegin()
13421 
    while True:
13422 
      (fname, ftype, fid) = iprot.readFieldBegin()
13423 
      if ftype == TType.STOP:
13424 
        break
3064 chandransh 13425 
      if fid == 1:
13426 
        if ftype == TType.STRUCT:
13427 
          self.ex = TransactionServiceException()
13428 
          self.ex.read(iprot)
13429 
        else:
13430 
          iprot.skip(ftype)
1596 ankur.sing 13431 
      else:
13432 
        iprot.skip(ftype)
13433 
      iprot.readFieldEnd()
13434 
    iprot.readStructEnd()
13435 
 
13436 
  def write(self, oprot):
13437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13439 
      return
3064 chandransh 13440 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 13441 
    if self.ex is not None:
3064 chandransh 13442 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13443 
      self.ex.write(oprot)
13444 
      oprot.writeFieldEnd()
1596 ankur.sing 13445 
    oprot.writeFieldStop()
13446 
    oprot.writeStructEnd()
13447 
 
3431 rajveer 13448 
  def validate(self):
13449 
    return
13450 
 
13451 
 
1596 ankur.sing 13452 
  def __repr__(self):
13453 
    L = ['%s=%r' % (key, value)
13454 
      for key, value in self.__dict__.iteritems()]
13455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13456 
 
13457 
  def __eq__(self, other):
13458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13459 
 
13460 
  def __ne__(self, other):
13461 
    return not (self == other)
13462 
 
4910 phani.kuma 13463 
class markAsRTOrders_args:
1596 ankur.sing 13464 
  """
13465 
  Attributes:
3064 chandransh 13466 
   - providerId
13467 
   - returnedOrders
1596 ankur.sing 13468 
  """
13469 
 
13470 
  thrift_spec = (
3064 chandransh 13471 
    None, # 0
13472 
    (1, TType.I64, 'providerId', None, None, ), # 1
13473 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 13474 
  )
13475 
 
3064 chandransh 13476 
  def __init__(self, providerId=None, returnedOrders=None,):
13477 
    self.providerId = providerId
13478 
    self.returnedOrders = returnedOrders
1596 ankur.sing 13479 
 
13480 
  def read(self, iprot):
13481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13483 
      return
13484 
    iprot.readStructBegin()
13485 
    while True:
13486 
      (fname, ftype, fid) = iprot.readFieldBegin()
13487 
      if ftype == TType.STOP:
13488 
        break
3064 chandransh 13489 
      if fid == 1:
1596 ankur.sing 13490 
        if ftype == TType.I64:
3064 chandransh 13491 
          self.providerId = iprot.readI64();
1596 ankur.sing 13492 
        else:
13493 
          iprot.skip(ftype)
3064 chandransh 13494 
      elif fid == 2:
13495 
        if ftype == TType.MAP:
13496 
          self.returnedOrders = {}
5713 rajveer 13497 
          (_ktype285, _vtype286, _size284 ) = iprot.readMapBegin()
13498 
          for _i288 in xrange(_size284):
13499 
            _key289 = iprot.readString();
13500 
            _val290 = iprot.readString();
13501 
            self.returnedOrders[_key289] = _val290
3064 chandransh 13502 
          iprot.readMapEnd()
13503 
        else:
13504 
          iprot.skip(ftype)
1596 ankur.sing 13505 
      else:
13506 
        iprot.skip(ftype)
13507 
      iprot.readFieldEnd()
13508 
    iprot.readStructEnd()
13509 
 
13510 
  def write(self, oprot):
13511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13513 
      return
4910 phani.kuma 13514 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 13515 
    if self.providerId is not None:
3064 chandransh 13516 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13517 
      oprot.writeI64(self.providerId)
1596 ankur.sing 13518 
      oprot.writeFieldEnd()
3431 rajveer 13519 
    if self.returnedOrders is not None:
3064 chandransh 13520 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
13521 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
5713 rajveer 13522 
      for kiter291,viter292 in self.returnedOrders.items():
13523 
        oprot.writeString(kiter291)
13524 
        oprot.writeString(viter292)
3064 chandransh 13525 
      oprot.writeMapEnd()
13526 
      oprot.writeFieldEnd()
1596 ankur.sing 13527 
    oprot.writeFieldStop()
13528 
    oprot.writeStructEnd()
13529 
 
3431 rajveer 13530 
  def validate(self):
13531 
    return
13532 
 
13533 
 
1596 ankur.sing 13534 
  def __repr__(self):
13535 
    L = ['%s=%r' % (key, value)
13536 
      for key, value in self.__dict__.iteritems()]
13537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13538 
 
13539 
  def __eq__(self, other):
13540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13541 
 
13542 
  def __ne__(self, other):
13543 
    return not (self == other)
13544 
 
4910 phani.kuma 13545 
class markAsRTOrders_result:
3064 chandransh 13546 
  """
13547 
  Attributes:
13548 
   - ex
13549 
  """
1596 ankur.sing 13550 
 
1627 ankur.sing 13551 
  thrift_spec = (
3064 chandransh 13552 
    None, # 0
13553 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13554 
  )
13555 
 
3064 chandransh 13556 
  def __init__(self, ex=None,):
13557 
    self.ex = ex
13558 
 
1627 ankur.sing 13559 
  def read(self, iprot):
13560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13562 
      return
13563 
    iprot.readStructBegin()
13564 
    while True:
13565 
      (fname, ftype, fid) = iprot.readFieldBegin()
13566 
      if ftype == TType.STOP:
13567 
        break
3064 chandransh 13568 
      if fid == 1:
13569 
        if ftype == TType.STRUCT:
13570 
          self.ex = TransactionServiceException()
13571 
          self.ex.read(iprot)
13572 
        else:
13573 
          iprot.skip(ftype)
1627 ankur.sing 13574 
      else:
13575 
        iprot.skip(ftype)
13576 
      iprot.readFieldEnd()
13577 
    iprot.readStructEnd()
13578 
 
13579 
  def write(self, oprot):
13580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13582 
      return
4910 phani.kuma 13583 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 13584 
    if self.ex is not None:
3064 chandransh 13585 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13586 
      self.ex.write(oprot)
13587 
      oprot.writeFieldEnd()
1627 ankur.sing 13588 
    oprot.writeFieldStop()
13589 
    oprot.writeStructEnd()
13590 
 
3431 rajveer 13591 
  def validate(self):
13592 
    return
13593 
 
13594 
 
1627 ankur.sing 13595 
  def __repr__(self):
13596 
    L = ['%s=%r' % (key, value)
13597 
      for key, value in self.__dict__.iteritems()]
13598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13599 
 
13600 
  def __eq__(self, other):
13601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13602 
 
13603 
  def __ne__(self, other):
13604 
    return not (self == other)
13605 
 
4910 phani.kuma 13606 
class getRTOrders_args:
13607 
  """
13608 
  Attributes:
13609 
   - providerId
13610 
  """
13611 
 
13612 
  thrift_spec = (
13613 
    None, # 0
13614 
    (1, TType.I64, 'providerId', None, None, ), # 1
13615 
  )
13616 
 
13617 
  def __init__(self, providerId=None,):
13618 
    self.providerId = providerId
13619 
 
13620 
  def read(self, iprot):
13621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13623 
      return
13624 
    iprot.readStructBegin()
13625 
    while True:
13626 
      (fname, ftype, fid) = iprot.readFieldBegin()
13627 
      if ftype == TType.STOP:
13628 
        break
13629 
      if fid == 1:
13630 
        if ftype == TType.I64:
13631 
          self.providerId = iprot.readI64();
13632 
        else:
13633 
          iprot.skip(ftype)
13634 
      else:
13635 
        iprot.skip(ftype)
13636 
      iprot.readFieldEnd()
13637 
    iprot.readStructEnd()
13638 
 
13639 
  def write(self, oprot):
13640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13642 
      return
13643 
    oprot.writeStructBegin('getRTOrders_args')
13644 
    if self.providerId is not None:
13645 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13646 
      oprot.writeI64(self.providerId)
13647 
      oprot.writeFieldEnd()
13648 
    oprot.writeFieldStop()
13649 
    oprot.writeStructEnd()
13650 
 
13651 
  def validate(self):
13652 
    return
13653 
 
13654 
 
13655 
  def __repr__(self):
13656 
    L = ['%s=%r' % (key, value)
13657 
      for key, value in self.__dict__.iteritems()]
13658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13659 
 
13660 
  def __eq__(self, other):
13661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13662 
 
13663 
  def __ne__(self, other):
13664 
    return not (self == other)
13665 
 
13666 
class getRTOrders_result:
13667 
  """
13668 
  Attributes:
13669 
   - success
13670 
  """
13671 
 
13672 
  thrift_spec = (
13673 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13674 
  )
13675 
 
13676 
  def __init__(self, success=None,):
13677 
    self.success = success
13678 
 
13679 
  def read(self, iprot):
13680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13682 
      return
13683 
    iprot.readStructBegin()
13684 
    while True:
13685 
      (fname, ftype, fid) = iprot.readFieldBegin()
13686 
      if ftype == TType.STOP:
13687 
        break
13688 
      if fid == 0:
13689 
        if ftype == TType.LIST:
13690 
          self.success = []
5713 rajveer 13691 
          (_etype296, _size293) = iprot.readListBegin()
13692 
          for _i297 in xrange(_size293):
13693 
            _elem298 = Order()
13694 
            _elem298.read(iprot)
13695 
            self.success.append(_elem298)
4910 phani.kuma 13696 
          iprot.readListEnd()
13697 
        else:
13698 
          iprot.skip(ftype)
13699 
      else:
13700 
        iprot.skip(ftype)
13701 
      iprot.readFieldEnd()
13702 
    iprot.readStructEnd()
13703 
 
13704 
  def write(self, oprot):
13705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13707 
      return
13708 
    oprot.writeStructBegin('getRTOrders_result')
13709 
    if self.success is not None:
13710 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13711 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 13712 
      for iter299 in self.success:
13713 
        iter299.write(oprot)
4910 phani.kuma 13714 
      oprot.writeListEnd()
13715 
      oprot.writeFieldEnd()
13716 
    oprot.writeFieldStop()
13717 
    oprot.writeStructEnd()
13718 
 
13719 
  def validate(self):
13720 
    return
13721 
 
13722 
 
13723 
  def __repr__(self):
13724 
    L = ['%s=%r' % (key, value)
13725 
      for key, value in self.__dict__.iteritems()]
13726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13727 
 
13728 
  def __eq__(self, other):
13729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13730 
 
13731 
  def __ne__(self, other):
13732 
    return not (self == other)
13733 
 
3064 chandransh 13734 
class updateNonDeliveryReason_args:
1627 ankur.sing 13735 
  """
13736 
  Attributes:
3064 chandransh 13737 
   - providerId
13738 
   - undeliveredOrders
1627 ankur.sing 13739 
  """
13740 
 
13741 
  thrift_spec = (
3064 chandransh 13742 
    None, # 0
13743 
    (1, TType.I64, 'providerId', None, None, ), # 1
13744 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 13745 
  )
13746 
 
3064 chandransh 13747 
  def __init__(self, providerId=None, undeliveredOrders=None,):
13748 
    self.providerId = providerId
13749 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 13750 
 
13751 
  def read(self, iprot):
13752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13754 
      return
13755 
    iprot.readStructBegin()
13756 
    while True:
13757 
      (fname, ftype, fid) = iprot.readFieldBegin()
13758 
      if ftype == TType.STOP:
13759 
        break
3064 chandransh 13760 
      if fid == 1:
1627 ankur.sing 13761 
        if ftype == TType.I64:
3064 chandransh 13762 
          self.providerId = iprot.readI64();
1627 ankur.sing 13763 
        else:
13764 
          iprot.skip(ftype)
3064 chandransh 13765 
      elif fid == 2:
13766 
        if ftype == TType.MAP:
13767 
          self.undeliveredOrders = {}
5713 rajveer 13768 
          (_ktype301, _vtype302, _size300 ) = iprot.readMapBegin()
13769 
          for _i304 in xrange(_size300):
13770 
            _key305 = iprot.readString();
13771 
            _val306 = iprot.readString();
13772 
            self.undeliveredOrders[_key305] = _val306
3064 chandransh 13773 
          iprot.readMapEnd()
13774 
        else:
13775 
          iprot.skip(ftype)
1627 ankur.sing 13776 
      else:
13777 
        iprot.skip(ftype)
13778 
      iprot.readFieldEnd()
13779 
    iprot.readStructEnd()
13780 
 
13781 
  def write(self, oprot):
13782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13784 
      return
3064 chandransh 13785 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 13786 
    if self.providerId is not None:
3064 chandransh 13787 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13788 
      oprot.writeI64(self.providerId)
1627 ankur.sing 13789 
      oprot.writeFieldEnd()
3431 rajveer 13790 
    if self.undeliveredOrders is not None:
3064 chandransh 13791 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
13792 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
5713 rajveer 13793 
      for kiter307,viter308 in self.undeliveredOrders.items():
13794 
        oprot.writeString(kiter307)
13795 
        oprot.writeString(viter308)
3064 chandransh 13796 
      oprot.writeMapEnd()
13797 
      oprot.writeFieldEnd()
1627 ankur.sing 13798 
    oprot.writeFieldStop()
13799 
    oprot.writeStructEnd()
13800 
 
3431 rajveer 13801 
  def validate(self):
13802 
    return
13803 
 
13804 
 
1627 ankur.sing 13805 
  def __repr__(self):
13806 
    L = ['%s=%r' % (key, value)
13807 
      for key, value in self.__dict__.iteritems()]
13808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13809 
 
13810 
  def __eq__(self, other):
13811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13812 
 
13813 
  def __ne__(self, other):
13814 
    return not (self == other)
13815 
 
3064 chandransh 13816 
class updateNonDeliveryReason_result:
1627 ankur.sing 13817 
  """
13818 
  Attributes:
3064 chandransh 13819 
   - ex
1627 ankur.sing 13820 
  """
13821 
 
13822 
  thrift_spec = (
4910 phani.kuma 13823 
    None, # 0
3064 chandransh 13824 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 13825 
  )
13826 
 
4910 phani.kuma 13827 
  def __init__(self, ex=None,):
3064 chandransh 13828 
    self.ex = ex
1627 ankur.sing 13829 
 
13830 
  def read(self, iprot):
13831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13833 
      return
13834 
    iprot.readStructBegin()
13835 
    while True:
13836 
      (fname, ftype, fid) = iprot.readFieldBegin()
13837 
      if ftype == TType.STOP:
13838 
        break
4910 phani.kuma 13839 
      if fid == 1:
13840 
        if ftype == TType.STRUCT:
13841 
          self.ex = TransactionServiceException()
13842 
          self.ex.read(iprot)
13843 
        else:
13844 
          iprot.skip(ftype)
13845 
      else:
13846 
        iprot.skip(ftype)
13847 
      iprot.readFieldEnd()
13848 
    iprot.readStructEnd()
13849 
 
13850 
  def write(self, oprot):
13851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13853 
      return
13854 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
13855 
    if self.ex is not None:
13856 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13857 
      self.ex.write(oprot)
13858 
      oprot.writeFieldEnd()
13859 
    oprot.writeFieldStop()
13860 
    oprot.writeStructEnd()
13861 
 
13862 
  def validate(self):
13863 
    return
13864 
 
13865 
 
13866 
  def __repr__(self):
13867 
    L = ['%s=%r' % (key, value)
13868 
      for key, value in self.__dict__.iteritems()]
13869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13870 
 
13871 
  def __eq__(self, other):
13872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13873 
 
13874 
  def __ne__(self, other):
13875 
    return not (self == other)
13876 
 
13877 
class getNonDeliveredOrdersbyCourier_args:
13878 
  """
13879 
  Attributes:
13880 
   - providerId
13881 
  """
13882 
 
13883 
  thrift_spec = (
13884 
    None, # 0
13885 
    (1, TType.I64, 'providerId', None, None, ), # 1
13886 
  )
13887 
 
13888 
  def __init__(self, providerId=None,):
13889 
    self.providerId = providerId
13890 
 
13891 
  def read(self, iprot):
13892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13894 
      return
13895 
    iprot.readStructBegin()
13896 
    while True:
13897 
      (fname, ftype, fid) = iprot.readFieldBegin()
13898 
      if ftype == TType.STOP:
13899 
        break
13900 
      if fid == 1:
13901 
        if ftype == TType.I64:
13902 
          self.providerId = iprot.readI64();
13903 
        else:
13904 
          iprot.skip(ftype)
13905 
      else:
13906 
        iprot.skip(ftype)
13907 
      iprot.readFieldEnd()
13908 
    iprot.readStructEnd()
13909 
 
13910 
  def write(self, oprot):
13911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13913 
      return
13914 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
13915 
    if self.providerId is not None:
13916 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13917 
      oprot.writeI64(self.providerId)
13918 
      oprot.writeFieldEnd()
13919 
    oprot.writeFieldStop()
13920 
    oprot.writeStructEnd()
13921 
 
13922 
  def validate(self):
13923 
    return
13924 
 
13925 
 
13926 
  def __repr__(self):
13927 
    L = ['%s=%r' % (key, value)
13928 
      for key, value in self.__dict__.iteritems()]
13929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13930 
 
13931 
  def __eq__(self, other):
13932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13933 
 
13934 
  def __ne__(self, other):
13935 
    return not (self == other)
13936 
 
13937 
class getNonDeliveredOrdersbyCourier_result:
13938 
  """
13939 
  Attributes:
13940 
   - success
13941 
  """
13942 
 
13943 
  thrift_spec = (
13944 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13945 
  )
13946 
 
13947 
  def __init__(self, success=None,):
13948 
    self.success = success
13949 
 
13950 
  def read(self, iprot):
13951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13953 
      return
13954 
    iprot.readStructBegin()
13955 
    while True:
13956 
      (fname, ftype, fid) = iprot.readFieldBegin()
13957 
      if ftype == TType.STOP:
13958 
        break
4581 phani.kuma 13959 
      if fid == 0:
13960 
        if ftype == TType.LIST:
13961 
          self.success = []
5713 rajveer 13962 
          (_etype312, _size309) = iprot.readListBegin()
13963 
          for _i313 in xrange(_size309):
13964 
            _elem314 = Order()
13965 
            _elem314.read(iprot)
13966 
            self.success.append(_elem314)
4581 phani.kuma 13967 
          iprot.readListEnd()
13968 
        else:
13969 
          iprot.skip(ftype)
4910 phani.kuma 13970 
      else:
13971 
        iprot.skip(ftype)
13972 
      iprot.readFieldEnd()
13973 
    iprot.readStructEnd()
13974 
 
13975 
  def write(self, oprot):
13976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13978 
      return
13979 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
13980 
    if self.success is not None:
13981 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13982 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 13983 
      for iter315 in self.success:
13984 
        iter315.write(oprot)
4910 phani.kuma 13985 
      oprot.writeListEnd()
13986 
      oprot.writeFieldEnd()
13987 
    oprot.writeFieldStop()
13988 
    oprot.writeStructEnd()
13989 
 
13990 
  def validate(self):
13991 
    return
13992 
 
13993 
 
13994 
  def __repr__(self):
13995 
    L = ['%s=%r' % (key, value)
13996 
      for key, value in self.__dict__.iteritems()]
13997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13998 
 
13999 
  def __eq__(self, other):
14000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14001 
 
14002 
  def __ne__(self, other):
14003 
    return not (self == other)
14004 
 
14005 
class markOrdersAsLocalConnected_args:
14006 
  """
14007 
  Attributes:
14008 
   - providerId
14009 
   - local_connected_orders
14010 
  """
14011 
 
14012 
  thrift_spec = (
14013 
    None, # 0
14014 
    (1, TType.I64, 'providerId', None, None, ), # 1
14015 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14016 
  )
14017 
 
14018 
  def __init__(self, providerId=None, local_connected_orders=None,):
14019 
    self.providerId = providerId
14020 
    self.local_connected_orders = local_connected_orders
14021 
 
14022 
  def read(self, iprot):
14023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14025 
      return
14026 
    iprot.readStructBegin()
14027 
    while True:
14028 
      (fname, ftype, fid) = iprot.readFieldBegin()
14029 
      if ftype == TType.STOP:
14030 
        break
14031 
      if fid == 1:
14032 
        if ftype == TType.I64:
14033 
          self.providerId = iprot.readI64();
14034 
        else:
14035 
          iprot.skip(ftype)
14036 
      elif fid == 2:
14037 
        if ftype == TType.MAP:
14038 
          self.local_connected_orders = {}
5713 rajveer 14039 
          (_ktype317, _vtype318, _size316 ) = iprot.readMapBegin()
14040 
          for _i320 in xrange(_size316):
14041 
            _key321 = iprot.readString();
14042 
            _val322 = iprot.readString();
14043 
            self.local_connected_orders[_key321] = _val322
4910 phani.kuma 14044 
          iprot.readMapEnd()
14045 
        else:
14046 
          iprot.skip(ftype)
14047 
      else:
14048 
        iprot.skip(ftype)
14049 
      iprot.readFieldEnd()
14050 
    iprot.readStructEnd()
14051 
 
14052 
  def write(self, oprot):
14053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14055 
      return
14056 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
14057 
    if self.providerId is not None:
14058 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14059 
      oprot.writeI64(self.providerId)
14060 
      oprot.writeFieldEnd()
14061 
    if self.local_connected_orders is not None:
14062 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
14063 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
5713 rajveer 14064 
      for kiter323,viter324 in self.local_connected_orders.items():
14065 
        oprot.writeString(kiter323)
14066 
        oprot.writeString(viter324)
4910 phani.kuma 14067 
      oprot.writeMapEnd()
14068 
      oprot.writeFieldEnd()
14069 
    oprot.writeFieldStop()
14070 
    oprot.writeStructEnd()
14071 
 
14072 
  def validate(self):
14073 
    return
14074 
 
14075 
 
14076 
  def __repr__(self):
14077 
    L = ['%s=%r' % (key, value)
14078 
      for key, value in self.__dict__.iteritems()]
14079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14080 
 
14081 
  def __eq__(self, other):
14082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14083 
 
14084 
  def __ne__(self, other):
14085 
    return not (self == other)
14086 
 
14087 
class markOrdersAsLocalConnected_result:
14088 
  """
14089 
  Attributes:
14090 
   - ex
14091 
  """
14092 
 
14093 
  thrift_spec = (
14094 
    None, # 0
14095 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14096 
  )
14097 
 
14098 
  def __init__(self, ex=None,):
14099 
    self.ex = ex
14100 
 
14101 
  def read(self, iprot):
14102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14104 
      return
14105 
    iprot.readStructBegin()
14106 
    while True:
14107 
      (fname, ftype, fid) = iprot.readFieldBegin()
14108 
      if ftype == TType.STOP:
14109 
        break
14110 
      if fid == 1:
3064 chandransh 14111 
        if ftype == TType.STRUCT:
14112 
          self.ex = TransactionServiceException()
14113 
          self.ex.read(iprot)
1627 ankur.sing 14114 
        else:
14115 
          iprot.skip(ftype)
14116 
      else:
14117 
        iprot.skip(ftype)
14118 
      iprot.readFieldEnd()
14119 
    iprot.readStructEnd()
14120 
 
14121 
  def write(self, oprot):
14122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14124 
      return
4910 phani.kuma 14125 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
14126 
    if self.ex is not None:
14127 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14128 
      self.ex.write(oprot)
14129 
      oprot.writeFieldEnd()
14130 
    oprot.writeFieldStop()
14131 
    oprot.writeStructEnd()
14132 
 
14133 
  def validate(self):
14134 
    return
14135 
 
14136 
 
14137 
  def __repr__(self):
14138 
    L = ['%s=%r' % (key, value)
14139 
      for key, value in self.__dict__.iteritems()]
14140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14141 
 
14142 
  def __eq__(self, other):
14143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14144 
 
14145 
  def __ne__(self, other):
14146 
    return not (self == other)
14147 
 
14148 
class getOrdersNotLocalConnected_args:
14149 
  """
14150 
  Attributes:
14151 
   - providerId
14152 
  """
14153 
 
14154 
  thrift_spec = (
14155 
    None, # 0
14156 
    (1, TType.I64, 'providerId', None, None, ), # 1
14157 
  )
14158 
 
14159 
  def __init__(self, providerId=None,):
14160 
    self.providerId = providerId
14161 
 
14162 
  def read(self, iprot):
14163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14165 
      return
14166 
    iprot.readStructBegin()
14167 
    while True:
14168 
      (fname, ftype, fid) = iprot.readFieldBegin()
14169 
      if ftype == TType.STOP:
14170 
        break
14171 
      if fid == 1:
14172 
        if ftype == TType.I64:
14173 
          self.providerId = iprot.readI64();
14174 
        else:
14175 
          iprot.skip(ftype)
14176 
      else:
14177 
        iprot.skip(ftype)
14178 
      iprot.readFieldEnd()
14179 
    iprot.readStructEnd()
14180 
 
14181 
  def write(self, oprot):
14182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14184 
      return
14185 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
14186 
    if self.providerId is not None:
14187 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14188 
      oprot.writeI64(self.providerId)
14189 
      oprot.writeFieldEnd()
14190 
    oprot.writeFieldStop()
14191 
    oprot.writeStructEnd()
14192 
 
14193 
  def validate(self):
14194 
    return
14195 
 
14196 
 
14197 
  def __repr__(self):
14198 
    L = ['%s=%r' % (key, value)
14199 
      for key, value in self.__dict__.iteritems()]
14200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14201 
 
14202 
  def __eq__(self, other):
14203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14204 
 
14205 
  def __ne__(self, other):
14206 
    return not (self == other)
14207 
 
14208 
class getOrdersNotLocalConnected_result:
14209 
  """
14210 
  Attributes:
14211 
   - success
14212 
  """
14213 
 
14214 
  thrift_spec = (
14215 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14216 
  )
14217 
 
14218 
  def __init__(self, success=None,):
14219 
    self.success = success
14220 
 
14221 
  def read(self, iprot):
14222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14224 
      return
14225 
    iprot.readStructBegin()
14226 
    while True:
14227 
      (fname, ftype, fid) = iprot.readFieldBegin()
14228 
      if ftype == TType.STOP:
14229 
        break
14230 
      if fid == 0:
14231 
        if ftype == TType.LIST:
14232 
          self.success = []
5713 rajveer 14233 
          (_etype328, _size325) = iprot.readListBegin()
14234 
          for _i329 in xrange(_size325):
14235 
            _elem330 = Order()
14236 
            _elem330.read(iprot)
14237 
            self.success.append(_elem330)
4910 phani.kuma 14238 
          iprot.readListEnd()
14239 
        else:
14240 
          iprot.skip(ftype)
14241 
      else:
14242 
        iprot.skip(ftype)
14243 
      iprot.readFieldEnd()
14244 
    iprot.readStructEnd()
14245 
 
14246 
  def write(self, oprot):
14247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14249 
      return
14250 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 14251 
    if self.success is not None:
14252 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14253 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 14254 
      for iter331 in self.success:
14255 
        iter331.write(oprot)
4581 phani.kuma 14256 
      oprot.writeListEnd()
14257 
      oprot.writeFieldEnd()
4910 phani.kuma 14258 
    oprot.writeFieldStop()
14259 
    oprot.writeStructEnd()
14260 
 
14261 
  def validate(self):
14262 
    return
14263 
 
14264 
 
14265 
  def __repr__(self):
14266 
    L = ['%s=%r' % (key, value)
14267 
      for key, value in self.__dict__.iteritems()]
14268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14269 
 
14270 
  def __eq__(self, other):
14271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14272 
 
14273 
  def __ne__(self, other):
14274 
    return not (self == other)
14275 
 
14276 
class markOrdersAsDestinationCityReached_args:
14277 
  """
14278 
  Attributes:
14279 
   - providerId
14280 
   - destination_city_reached_orders
14281 
  """
14282 
 
14283 
  thrift_spec = (
14284 
    None, # 0
14285 
    (1, TType.I64, 'providerId', None, None, ), # 1
14286 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14287 
  )
14288 
 
14289 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
14290 
    self.providerId = providerId
14291 
    self.destination_city_reached_orders = destination_city_reached_orders
14292 
 
14293 
  def read(self, iprot):
14294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14296 
      return
14297 
    iprot.readStructBegin()
14298 
    while True:
14299 
      (fname, ftype, fid) = iprot.readFieldBegin()
14300 
      if ftype == TType.STOP:
14301 
        break
14302 
      if fid == 1:
14303 
        if ftype == TType.I64:
14304 
          self.providerId = iprot.readI64();
14305 
        else:
14306 
          iprot.skip(ftype)
14307 
      elif fid == 2:
14308 
        if ftype == TType.MAP:
14309 
          self.destination_city_reached_orders = {}
5713 rajveer 14310 
          (_ktype333, _vtype334, _size332 ) = iprot.readMapBegin()
14311 
          for _i336 in xrange(_size332):
14312 
            _key337 = iprot.readString();
14313 
            _val338 = iprot.readString();
14314 
            self.destination_city_reached_orders[_key337] = _val338
4910 phani.kuma 14315 
          iprot.readMapEnd()
14316 
        else:
14317 
          iprot.skip(ftype)
14318 
      else:
14319 
        iprot.skip(ftype)
14320 
      iprot.readFieldEnd()
14321 
    iprot.readStructEnd()
14322 
 
14323 
  def write(self, oprot):
14324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14326 
      return
14327 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
14328 
    if self.providerId is not None:
14329 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14330 
      oprot.writeI64(self.providerId)
14331 
      oprot.writeFieldEnd()
14332 
    if self.destination_city_reached_orders is not None:
14333 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
14334 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
5713 rajveer 14335 
      for kiter339,viter340 in self.destination_city_reached_orders.items():
14336 
        oprot.writeString(kiter339)
14337 
        oprot.writeString(viter340)
4910 phani.kuma 14338 
      oprot.writeMapEnd()
14339 
      oprot.writeFieldEnd()
14340 
    oprot.writeFieldStop()
14341 
    oprot.writeStructEnd()
14342 
 
14343 
  def validate(self):
14344 
    return
14345 
 
14346 
 
14347 
  def __repr__(self):
14348 
    L = ['%s=%r' % (key, value)
14349 
      for key, value in self.__dict__.iteritems()]
14350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14351 
 
14352 
  def __eq__(self, other):
14353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14354 
 
14355 
  def __ne__(self, other):
14356 
    return not (self == other)
14357 
 
14358 
class markOrdersAsDestinationCityReached_result:
14359 
  """
14360 
  Attributes:
14361 
   - ex
14362 
  """
14363 
 
14364 
  thrift_spec = (
14365 
    None, # 0
14366 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14367 
  )
14368 
 
14369 
  def __init__(self, ex=None,):
14370 
    self.ex = ex
14371 
 
14372 
  def read(self, iprot):
14373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14375 
      return
14376 
    iprot.readStructBegin()
14377 
    while True:
14378 
      (fname, ftype, fid) = iprot.readFieldBegin()
14379 
      if ftype == TType.STOP:
14380 
        break
14381 
      if fid == 1:
14382 
        if ftype == TType.STRUCT:
14383 
          self.ex = TransactionServiceException()
14384 
          self.ex.read(iprot)
14385 
        else:
14386 
          iprot.skip(ftype)
14387 
      else:
14388 
        iprot.skip(ftype)
14389 
      iprot.readFieldEnd()
14390 
    iprot.readStructEnd()
14391 
 
14392 
  def write(self, oprot):
14393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14395 
      return
14396 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 14397 
    if self.ex is not None:
3064 chandransh 14398 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14399 
      self.ex.write(oprot)
1627 ankur.sing 14400 
      oprot.writeFieldEnd()
14401 
    oprot.writeFieldStop()
14402 
    oprot.writeStructEnd()
14403 
 
3431 rajveer 14404 
  def validate(self):
14405 
    return
14406 
 
14407 
 
1627 ankur.sing 14408 
  def __repr__(self):
14409 
    L = ['%s=%r' % (key, value)
14410 
      for key, value in self.__dict__.iteritems()]
14411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14412 
 
14413 
  def __eq__(self, other):
14414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14415 
 
14416 
  def __ne__(self, other):
14417 
    return not (self == other)
14418 
 
4910 phani.kuma 14419 
class markOrdersAsFirstDeliveryAttempted_args:
14420 
  """
14421 
  Attributes:
14422 
   - providerId
14423 
   - first_atdl_orders
14424 
  """
14425 
 
14426 
  thrift_spec = (
14427 
    None, # 0
14428 
    (1, TType.I64, 'providerId', None, None, ), # 1
14429 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14430 
  )
14431 
 
14432 
  def __init__(self, providerId=None, first_atdl_orders=None,):
14433 
    self.providerId = providerId
14434 
    self.first_atdl_orders = first_atdl_orders
14435 
 
14436 
  def read(self, iprot):
14437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14439 
      return
14440 
    iprot.readStructBegin()
14441 
    while True:
14442 
      (fname, ftype, fid) = iprot.readFieldBegin()
14443 
      if ftype == TType.STOP:
14444 
        break
14445 
      if fid == 1:
14446 
        if ftype == TType.I64:
14447 
          self.providerId = iprot.readI64();
14448 
        else:
14449 
          iprot.skip(ftype)
14450 
      elif fid == 2:
14451 
        if ftype == TType.MAP:
14452 
          self.first_atdl_orders = {}
5713 rajveer 14453 
          (_ktype342, _vtype343, _size341 ) = iprot.readMapBegin()
14454 
          for _i345 in xrange(_size341):
14455 
            _key346 = iprot.readString();
14456 
            _val347 = iprot.readString();
14457 
            self.first_atdl_orders[_key346] = _val347
4910 phani.kuma 14458 
          iprot.readMapEnd()
14459 
        else:
14460 
          iprot.skip(ftype)
14461 
      else:
14462 
        iprot.skip(ftype)
14463 
      iprot.readFieldEnd()
14464 
    iprot.readStructEnd()
14465 
 
14466 
  def write(self, oprot):
14467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14469 
      return
14470 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
14471 
    if self.providerId is not None:
14472 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14473 
      oprot.writeI64(self.providerId)
14474 
      oprot.writeFieldEnd()
14475 
    if self.first_atdl_orders is not None:
14476 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
14477 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
5713 rajveer 14478 
      for kiter348,viter349 in self.first_atdl_orders.items():
14479 
        oprot.writeString(kiter348)
14480 
        oprot.writeString(viter349)
4910 phani.kuma 14481 
      oprot.writeMapEnd()
14482 
      oprot.writeFieldEnd()
14483 
    oprot.writeFieldStop()
14484 
    oprot.writeStructEnd()
14485 
 
14486 
  def validate(self):
14487 
    return
14488 
 
14489 
 
14490 
  def __repr__(self):
14491 
    L = ['%s=%r' % (key, value)
14492 
      for key, value in self.__dict__.iteritems()]
14493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14494 
 
14495 
  def __eq__(self, other):
14496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14497 
 
14498 
  def __ne__(self, other):
14499 
    return not (self == other)
14500 
 
14501 
class markOrdersAsFirstDeliveryAttempted_result:
14502 
  """
14503 
  Attributes:
14504 
   - ex
14505 
  """
14506 
 
14507 
  thrift_spec = (
14508 
    None, # 0
14509 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14510 
  )
14511 
 
14512 
  def __init__(self, ex=None,):
14513 
    self.ex = ex
14514 
 
14515 
  def read(self, iprot):
14516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14518 
      return
14519 
    iprot.readStructBegin()
14520 
    while True:
14521 
      (fname, ftype, fid) = iprot.readFieldBegin()
14522 
      if ftype == TType.STOP:
14523 
        break
14524 
      if fid == 1:
14525 
        if ftype == TType.STRUCT:
14526 
          self.ex = TransactionServiceException()
14527 
          self.ex.read(iprot)
14528 
        else:
14529 
          iprot.skip(ftype)
14530 
      else:
14531 
        iprot.skip(ftype)
14532 
      iprot.readFieldEnd()
14533 
    iprot.readStructEnd()
14534 
 
14535 
  def write(self, oprot):
14536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14538 
      return
14539 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
14540 
    if self.ex is not None:
14541 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14542 
      self.ex.write(oprot)
14543 
      oprot.writeFieldEnd()
14544 
    oprot.writeFieldStop()
14545 
    oprot.writeStructEnd()
14546 
 
14547 
  def validate(self):
14548 
    return
14549 
 
14550 
 
14551 
  def __repr__(self):
14552 
    L = ['%s=%r' % (key, value)
14553 
      for key, value in self.__dict__.iteritems()]
14554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14555 
 
14556 
  def __eq__(self, other):
14557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14558 
 
14559 
  def __ne__(self, other):
14560 
    return not (self == other)
14561 
 
3064 chandransh 14562 
class getUndeliveredOrders_args:
1886 ankur.sing 14563 
  """
14564 
  Attributes:
3064 chandransh 14565 
   - providerId
14566 
   - warehouseId
1886 ankur.sing 14567 
  """
1627 ankur.sing 14568 
 
1886 ankur.sing 14569 
  thrift_spec = (
14570 
    None, # 0
3064 chandransh 14571 
    (1, TType.I64, 'providerId', None, None, ), # 1
14572 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 14573 
  )
14574 
 
3064 chandransh 14575 
  def __init__(self, providerId=None, warehouseId=None,):
14576 
    self.providerId = providerId
14577 
    self.warehouseId = warehouseId
1886 ankur.sing 14578 
 
14579 
  def read(self, iprot):
14580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14582 
      return
14583 
    iprot.readStructBegin()
14584 
    while True:
14585 
      (fname, ftype, fid) = iprot.readFieldBegin()
14586 
      if ftype == TType.STOP:
14587 
        break
14588 
      if fid == 1:
14589 
        if ftype == TType.I64:
3064 chandransh 14590 
          self.providerId = iprot.readI64();
1886 ankur.sing 14591 
        else:
14592 
          iprot.skip(ftype)
3064 chandransh 14593 
      elif fid == 2:
14594 
        if ftype == TType.I64:
14595 
          self.warehouseId = iprot.readI64();
14596 
        else:
14597 
          iprot.skip(ftype)
1886 ankur.sing 14598 
      else:
14599 
        iprot.skip(ftype)
14600 
      iprot.readFieldEnd()
14601 
    iprot.readStructEnd()
14602 
 
14603 
  def write(self, oprot):
14604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14606 
      return
3064 chandransh 14607 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 14608 
    if self.providerId is not None:
3064 chandransh 14609 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14610 
      oprot.writeI64(self.providerId)
1886 ankur.sing 14611 
      oprot.writeFieldEnd()
3431 rajveer 14612 
    if self.warehouseId is not None:
3064 chandransh 14613 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
14614 
      oprot.writeI64(self.warehouseId)
14615 
      oprot.writeFieldEnd()
1886 ankur.sing 14616 
    oprot.writeFieldStop()
14617 
    oprot.writeStructEnd()
14618 
 
3431 rajveer 14619 
  def validate(self):
14620 
    return
14621 
 
14622 
 
1886 ankur.sing 14623 
  def __repr__(self):
14624 
    L = ['%s=%r' % (key, value)
14625 
      for key, value in self.__dict__.iteritems()]
14626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14627 
 
14628 
  def __eq__(self, other):
14629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14630 
 
14631 
  def __ne__(self, other):
14632 
    return not (self == other)
14633 
 
3064 chandransh 14634 
class getUndeliveredOrders_result:
1886 ankur.sing 14635 
  """
14636 
  Attributes:
14637 
   - success
14638 
  """
14639 
 
14640 
  thrift_spec = (
14641 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14642 
  )
14643 
 
14644 
  def __init__(self, success=None,):
14645 
    self.success = success
14646 
 
14647 
  def read(self, iprot):
14648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14650 
      return
14651 
    iprot.readStructBegin()
14652 
    while True:
14653 
      (fname, ftype, fid) = iprot.readFieldBegin()
14654 
      if ftype == TType.STOP:
14655 
        break
14656 
      if fid == 0:
14657 
        if ftype == TType.LIST:
14658 
          self.success = []
5713 rajveer 14659 
          (_etype353, _size350) = iprot.readListBegin()
14660 
          for _i354 in xrange(_size350):
14661 
            _elem355 = Order()
14662 
            _elem355.read(iprot)
14663 
            self.success.append(_elem355)
1886 ankur.sing 14664 
          iprot.readListEnd()
14665 
        else:
14666 
          iprot.skip(ftype)
14667 
      else:
14668 
        iprot.skip(ftype)
14669 
      iprot.readFieldEnd()
14670 
    iprot.readStructEnd()
14671 
 
14672 
  def write(self, oprot):
14673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14675 
      return
3064 chandransh 14676 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 14677 
    if self.success is not None:
1886 ankur.sing 14678 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14679 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 14680 
      for iter356 in self.success:
14681 
        iter356.write(oprot)
1886 ankur.sing 14682 
      oprot.writeListEnd()
14683 
      oprot.writeFieldEnd()
14684 
    oprot.writeFieldStop()
14685 
    oprot.writeStructEnd()
14686 
 
3431 rajveer 14687 
  def validate(self):
14688 
    return
14689 
 
14690 
 
1886 ankur.sing 14691 
  def __repr__(self):
14692 
    L = ['%s=%r' % (key, value)
14693 
      for key, value in self.__dict__.iteritems()]
14694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14695 
 
14696 
  def __eq__(self, other):
14697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14698 
 
14699 
  def __ne__(self, other):
14700 
    return not (self == other)
14701 
 
4783 phani.kuma 14702 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
14703 
 
14704 
  thrift_spec = (
14705 
  )
14706 
 
14707 
  def read(self, iprot):
14708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14710 
      return
14711 
    iprot.readStructBegin()
14712 
    while True:
14713 
      (fname, ftype, fid) = iprot.readFieldBegin()
14714 
      if ftype == TType.STOP:
14715 
        break
14716 
      else:
14717 
        iprot.skip(ftype)
14718 
      iprot.readFieldEnd()
14719 
    iprot.readStructEnd()
14720 
 
14721 
  def write(self, oprot):
14722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14724 
      return
14725 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
14726 
    oprot.writeFieldStop()
14727 
    oprot.writeStructEnd()
14728 
 
14729 
  def validate(self):
14730 
    return
14731 
 
14732 
 
14733 
  def __repr__(self):
14734 
    L = ['%s=%r' % (key, value)
14735 
      for key, value in self.__dict__.iteritems()]
14736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14737 
 
14738 
  def __eq__(self, other):
14739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14740 
 
14741 
  def __ne__(self, other):
14742 
    return not (self == other)
14743 
 
14744 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
14745 
  """
14746 
  Attributes:
14747 
   - success
14748 
  """
14749 
 
14750 
  thrift_spec = (
14751 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14752 
  )
14753 
 
14754 
  def __init__(self, success=None,):
14755 
    self.success = success
14756 
 
14757 
  def read(self, iprot):
14758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14760 
      return
14761 
    iprot.readStructBegin()
14762 
    while True:
14763 
      (fname, ftype, fid) = iprot.readFieldBegin()
14764 
      if ftype == TType.STOP:
14765 
        break
14766 
      if fid == 0:
14767 
        if ftype == TType.LIST:
14768 
          self.success = []
5713 rajveer 14769 
          (_etype360, _size357) = iprot.readListBegin()
14770 
          for _i361 in xrange(_size357):
14771 
            _elem362 = Order()
14772 
            _elem362.read(iprot)
14773 
            self.success.append(_elem362)
4783 phani.kuma 14774 
          iprot.readListEnd()
14775 
        else:
14776 
          iprot.skip(ftype)
14777 
      else:
14778 
        iprot.skip(ftype)
14779 
      iprot.readFieldEnd()
14780 
    iprot.readStructEnd()
14781 
 
14782 
  def write(self, oprot):
14783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14785 
      return
14786 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
14787 
    if self.success is not None:
14788 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14789 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 14790 
      for iter363 in self.success:
14791 
        iter363.write(oprot)
4783 phani.kuma 14792 
      oprot.writeListEnd()
14793 
      oprot.writeFieldEnd()
14794 
    oprot.writeFieldStop()
14795 
    oprot.writeStructEnd()
14796 
 
14797 
  def validate(self):
14798 
    return
14799 
 
14800 
 
14801 
  def __repr__(self):
14802 
    L = ['%s=%r' % (key, value)
14803 
      for key, value in self.__dict__.iteritems()]
14804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14805 
 
14806 
  def __eq__(self, other):
14807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14808 
 
14809 
  def __ne__(self, other):
14810 
    return not (self == other)
14811 
 
2536 chandransh 14812 
class toggleDOAFlag_args:
14813 
  """
14814 
  Attributes:
14815 
   - orderId
14816 
  """
1886 ankur.sing 14817 
 
2536 chandransh 14818 
  thrift_spec = (
14819 
    None, # 0
14820 
    (1, TType.I64, 'orderId', None, None, ), # 1
14821 
  )
14822 
 
14823 
  def __init__(self, orderId=None,):
14824 
    self.orderId = orderId
14825 
 
14826 
  def read(self, iprot):
14827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14829 
      return
14830 
    iprot.readStructBegin()
14831 
    while True:
14832 
      (fname, ftype, fid) = iprot.readFieldBegin()
14833 
      if ftype == TType.STOP:
14834 
        break
14835 
      if fid == 1:
14836 
        if ftype == TType.I64:
14837 
          self.orderId = iprot.readI64();
14838 
        else:
14839 
          iprot.skip(ftype)
14840 
      else:
14841 
        iprot.skip(ftype)
14842 
      iprot.readFieldEnd()
14843 
    iprot.readStructEnd()
14844 
 
14845 
  def write(self, oprot):
14846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14848 
      return
14849 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 14850 
    if self.orderId is not None:
2536 chandransh 14851 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14852 
      oprot.writeI64(self.orderId)
14853 
      oprot.writeFieldEnd()
14854 
    oprot.writeFieldStop()
14855 
    oprot.writeStructEnd()
14856 
 
3431 rajveer 14857 
  def validate(self):
14858 
    return
14859 
 
14860 
 
2536 chandransh 14861 
  def __repr__(self):
14862 
    L = ['%s=%r' % (key, value)
14863 
      for key, value in self.__dict__.iteritems()]
14864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14865 
 
14866 
  def __eq__(self, other):
14867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14868 
 
14869 
  def __ne__(self, other):
14870 
    return not (self == other)
14871 
 
14872 
class toggleDOAFlag_result:
14873 
  """
14874 
  Attributes:
14875 
   - success
14876 
   - ex
14877 
  """
14878 
 
14879 
  thrift_spec = (
14880 
    (0, TType.BOOL, 'success', None, None, ), # 0
14881 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14882 
  )
14883 
 
14884 
  def __init__(self, success=None, ex=None,):
14885 
    self.success = success
14886 
    self.ex = ex
14887 
 
14888 
  def read(self, iprot):
14889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14891 
      return
14892 
    iprot.readStructBegin()
14893 
    while True:
14894 
      (fname, ftype, fid) = iprot.readFieldBegin()
14895 
      if ftype == TType.STOP:
14896 
        break
14897 
      if fid == 0:
14898 
        if ftype == TType.BOOL:
14899 
          self.success = iprot.readBool();
14900 
        else:
14901 
          iprot.skip(ftype)
14902 
      elif fid == 1:
14903 
        if ftype == TType.STRUCT:
14904 
          self.ex = TransactionServiceException()
14905 
          self.ex.read(iprot)
14906 
        else:
14907 
          iprot.skip(ftype)
14908 
      else:
14909 
        iprot.skip(ftype)
14910 
      iprot.readFieldEnd()
14911 
    iprot.readStructEnd()
14912 
 
14913 
  def write(self, oprot):
14914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14916 
      return
14917 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 14918 
    if self.success is not None:
2536 chandransh 14919 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14920 
      oprot.writeBool(self.success)
14921 
      oprot.writeFieldEnd()
3431 rajveer 14922 
    if self.ex is not None:
2536 chandransh 14923 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14924 
      self.ex.write(oprot)
14925 
      oprot.writeFieldEnd()
14926 
    oprot.writeFieldStop()
14927 
    oprot.writeStructEnd()
14928 
 
3431 rajveer 14929 
  def validate(self):
14930 
    return
14931 
 
14932 
 
2536 chandransh 14933 
  def __repr__(self):
14934 
    L = ['%s=%r' % (key, value)
14935 
      for key, value in self.__dict__.iteritems()]
14936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14937 
 
14938 
  def __eq__(self, other):
14939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14940 
 
14941 
  def __ne__(self, other):
14942 
    return not (self == other)
14943 
 
4712 rajveer 14944 
class markOrderAsDelivered_args:
14945 
  """
14946 
  Attributes:
14947 
   - orderId
14948 
   - deliveryTimestamp
14949 
   - receiver
14950 
  """
14951 
 
14952 
  thrift_spec = None
14953 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
14954 
    self.orderId = orderId
14955 
    self.deliveryTimestamp = deliveryTimestamp
14956 
    self.receiver = receiver
14957 
 
14958 
  def read(self, iprot):
14959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14961 
      return
14962 
    iprot.readStructBegin()
14963 
    while True:
14964 
      (fname, ftype, fid) = iprot.readFieldBegin()
14965 
      if ftype == TType.STOP:
14966 
        break
14967 
      if fid == 1:
14968 
        if ftype == TType.I64:
14969 
          self.orderId = iprot.readI64();
14970 
        else:
14971 
          iprot.skip(ftype)
14972 
      elif fid == 2:
14973 
        if ftype == TType.I64:
14974 
          self.deliveryTimestamp = iprot.readI64();
14975 
        else:
14976 
          iprot.skip(ftype)
14977 
      elif fid == -1:
14978 
        if ftype == TType.STRING:
14979 
          self.receiver = iprot.readString();
14980 
        else:
14981 
          iprot.skip(ftype)
14982 
      else:
14983 
        iprot.skip(ftype)
14984 
      iprot.readFieldEnd()
14985 
    iprot.readStructEnd()
14986 
 
14987 
  def write(self, oprot):
14988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14990 
      return
14991 
    oprot.writeStructBegin('markOrderAsDelivered_args')
14992 
    if self.receiver is not None:
14993 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
14994 
      oprot.writeString(self.receiver)
14995 
      oprot.writeFieldEnd()
14996 
    if self.orderId is not None:
14997 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14998 
      oprot.writeI64(self.orderId)
14999 
      oprot.writeFieldEnd()
15000 
    if self.deliveryTimestamp is not None:
15001 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15002 
      oprot.writeI64(self.deliveryTimestamp)
15003 
      oprot.writeFieldEnd()
15004 
    oprot.writeFieldStop()
15005 
    oprot.writeStructEnd()
15006 
 
15007 
  def validate(self):
15008 
    return
15009 
 
15010 
 
15011 
  def __repr__(self):
15012 
    L = ['%s=%r' % (key, value)
15013 
      for key, value in self.__dict__.iteritems()]
15014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15015 
 
15016 
  def __eq__(self, other):
15017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15018 
 
15019 
  def __ne__(self, other):
15020 
    return not (self == other)
15021 
 
15022 
class markOrderAsDelivered_result:
15023 
  """
15024 
  Attributes:
15025 
   - ex
15026 
  """
15027 
 
15028 
  thrift_spec = (
15029 
    None, # 0
15030 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15031 
  )
15032 
 
15033 
  def __init__(self, ex=None,):
15034 
    self.ex = ex
15035 
 
15036 
  def read(self, iprot):
15037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15039 
      return
15040 
    iprot.readStructBegin()
15041 
    while True:
15042 
      (fname, ftype, fid) = iprot.readFieldBegin()
15043 
      if ftype == TType.STOP:
15044 
        break
15045 
      if fid == 1:
15046 
        if ftype == TType.STRUCT:
15047 
          self.ex = TransactionServiceException()
15048 
          self.ex.read(iprot)
15049 
        else:
15050 
          iprot.skip(ftype)
15051 
      else:
15052 
        iprot.skip(ftype)
15053 
      iprot.readFieldEnd()
15054 
    iprot.readStructEnd()
15055 
 
15056 
  def write(self, oprot):
15057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15059 
      return
15060 
    oprot.writeStructBegin('markOrderAsDelivered_result')
15061 
    if self.ex is not None:
15062 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15063 
      self.ex.write(oprot)
15064 
      oprot.writeFieldEnd()
15065 
    oprot.writeFieldStop()
15066 
    oprot.writeStructEnd()
15067 
 
15068 
  def validate(self):
15069 
    return
15070 
 
15071 
 
15072 
  def __repr__(self):
15073 
    L = ['%s=%r' % (key, value)
15074 
      for key, value in self.__dict__.iteritems()]
15075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15076 
 
15077 
  def __eq__(self, other):
15078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15079 
 
15080 
  def __ne__(self, other):
15081 
    return not (self == other)
15082 
 
5553 rajveer 15083 
class markOrderAsReceivedAtStore_args:
15084 
  """
15085 
  Attributes:
15086 
   - orderId
15087 
   - deliveryTimestamp
15088 
  """
15089 
 
15090 
  thrift_spec = (
15091 
    None, # 0
15092 
    (1, TType.I64, 'orderId', None, None, ), # 1
15093 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
15094 
  )
15095 
 
15096 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
15097 
    self.orderId = orderId
15098 
    self.deliveryTimestamp = deliveryTimestamp
15099 
 
15100 
  def read(self, iprot):
15101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15103 
      return
15104 
    iprot.readStructBegin()
15105 
    while True:
15106 
      (fname, ftype, fid) = iprot.readFieldBegin()
15107 
      if ftype == TType.STOP:
15108 
        break
15109 
      if fid == 1:
15110 
        if ftype == TType.I64:
15111 
          self.orderId = iprot.readI64();
15112 
        else:
15113 
          iprot.skip(ftype)
15114 
      elif fid == 2:
15115 
        if ftype == TType.I64:
15116 
          self.deliveryTimestamp = iprot.readI64();
15117 
        else:
15118 
          iprot.skip(ftype)
15119 
      else:
15120 
        iprot.skip(ftype)
15121 
      iprot.readFieldEnd()
15122 
    iprot.readStructEnd()
15123 
 
15124 
  def write(self, oprot):
15125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15127 
      return
15128 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
15129 
    if self.orderId is not None:
15130 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15131 
      oprot.writeI64(self.orderId)
15132 
      oprot.writeFieldEnd()
15133 
    if self.deliveryTimestamp is not None:
15134 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15135 
      oprot.writeI64(self.deliveryTimestamp)
15136 
      oprot.writeFieldEnd()
15137 
    oprot.writeFieldStop()
15138 
    oprot.writeStructEnd()
15139 
 
15140 
  def validate(self):
15141 
    return
15142 
 
15143 
 
15144 
  def __repr__(self):
15145 
    L = ['%s=%r' % (key, value)
15146 
      for key, value in self.__dict__.iteritems()]
15147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15148 
 
15149 
  def __eq__(self, other):
15150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15151 
 
15152 
  def __ne__(self, other):
15153 
    return not (self == other)
15154 
 
15155 
class markOrderAsReceivedAtStore_result:
15156 
  """
15157 
  Attributes:
15158 
   - ex
15159 
  """
15160 
 
15161 
  thrift_spec = (
15162 
    None, # 0
15163 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15164 
  )
15165 
 
15166 
  def __init__(self, ex=None,):
15167 
    self.ex = ex
15168 
 
15169 
  def read(self, iprot):
15170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15172 
      return
15173 
    iprot.readStructBegin()
15174 
    while True:
15175 
      (fname, ftype, fid) = iprot.readFieldBegin()
15176 
      if ftype == TType.STOP:
15177 
        break
15178 
      if fid == 1:
15179 
        if ftype == TType.STRUCT:
15180 
          self.ex = TransactionServiceException()
15181 
          self.ex.read(iprot)
15182 
        else:
15183 
          iprot.skip(ftype)
15184 
      else:
15185 
        iprot.skip(ftype)
15186 
      iprot.readFieldEnd()
15187 
    iprot.readStructEnd()
15188 
 
15189 
  def write(self, oprot):
15190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15192 
      return
15193 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
15194 
    if self.ex is not None:
15195 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15196 
      self.ex.write(oprot)
15197 
      oprot.writeFieldEnd()
15198 
    oprot.writeFieldStop()
15199 
    oprot.writeStructEnd()
15200 
 
15201 
  def validate(self):
15202 
    return
15203 
 
15204 
 
15205 
  def __repr__(self):
15206 
    L = ['%s=%r' % (key, value)
15207 
      for key, value in self.__dict__.iteritems()]
15208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15209 
 
15210 
  def __eq__(self, other):
15211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15212 
 
15213 
  def __ne__(self, other):
15214 
    return not (self == other)
15215 
 
4454 rajveer 15216 
class markOrderDoaRequestReceived_args:
15217 
  """
15218 
  Attributes:
15219 
   - orderId
15220 
  """
15221 
 
15222 
  thrift_spec = (
15223 
    None, # 0
15224 
    (1, TType.I64, 'orderId', None, None, ), # 1
15225 
  )
15226 
 
15227 
  def __init__(self, orderId=None,):
15228 
    self.orderId = orderId
15229 
 
15230 
  def read(self, iprot):
15231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15233 
      return
15234 
    iprot.readStructBegin()
15235 
    while True:
15236 
      (fname, ftype, fid) = iprot.readFieldBegin()
15237 
      if ftype == TType.STOP:
15238 
        break
15239 
      if fid == 1:
15240 
        if ftype == TType.I64:
15241 
          self.orderId = iprot.readI64();
15242 
        else:
15243 
          iprot.skip(ftype)
15244 
      else:
15245 
        iprot.skip(ftype)
15246 
      iprot.readFieldEnd()
15247 
    iprot.readStructEnd()
15248 
 
15249 
  def write(self, oprot):
15250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15252 
      return
15253 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
15254 
    if self.orderId is not None:
15255 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15256 
      oprot.writeI64(self.orderId)
15257 
      oprot.writeFieldEnd()
15258 
    oprot.writeFieldStop()
15259 
    oprot.writeStructEnd()
15260 
 
15261 
  def validate(self):
15262 
    return
15263 
 
15264 
 
15265 
  def __repr__(self):
15266 
    L = ['%s=%r' % (key, value)
15267 
      for key, value in self.__dict__.iteritems()]
15268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15269 
 
15270 
  def __eq__(self, other):
15271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15272 
 
15273 
  def __ne__(self, other):
15274 
    return not (self == other)
15275 
 
15276 
class markOrderDoaRequestReceived_result:
15277 
  """
15278 
  Attributes:
15279 
   - success
15280 
   - ex
15281 
  """
15282 
 
15283 
  thrift_spec = (
15284 
    (0, TType.BOOL, 'success', None, None, ), # 0
15285 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15286 
  )
15287 
 
15288 
  def __init__(self, success=None, ex=None,):
15289 
    self.success = success
15290 
    self.ex = ex
15291 
 
15292 
  def read(self, iprot):
15293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15295 
      return
15296 
    iprot.readStructBegin()
15297 
    while True:
15298 
      (fname, ftype, fid) = iprot.readFieldBegin()
15299 
      if ftype == TType.STOP:
15300 
        break
15301 
      if fid == 0:
15302 
        if ftype == TType.BOOL:
15303 
          self.success = iprot.readBool();
15304 
        else:
15305 
          iprot.skip(ftype)
15306 
      elif fid == 1:
15307 
        if ftype == TType.STRUCT:
15308 
          self.ex = TransactionServiceException()
15309 
          self.ex.read(iprot)
15310 
        else:
15311 
          iprot.skip(ftype)
15312 
      else:
15313 
        iprot.skip(ftype)
15314 
      iprot.readFieldEnd()
15315 
    iprot.readStructEnd()
15316 
 
15317 
  def write(self, oprot):
15318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15320 
      return
15321 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
15322 
    if self.success is not None:
15323 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15324 
      oprot.writeBool(self.success)
15325 
      oprot.writeFieldEnd()
15326 
    if self.ex is not None:
15327 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15328 
      self.ex.write(oprot)
15329 
      oprot.writeFieldEnd()
15330 
    oprot.writeFieldStop()
15331 
    oprot.writeStructEnd()
15332 
 
15333 
  def validate(self):
15334 
    return
15335 
 
15336 
 
15337 
  def __repr__(self):
15338 
    L = ['%s=%r' % (key, value)
15339 
      for key, value in self.__dict__.iteritems()]
15340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15341 
 
15342 
  def __eq__(self, other):
15343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15344 
 
15345 
  def __ne__(self, other):
15346 
    return not (self == other)
15347 
 
15348 
class markOrderDoaRequestAuthorized_args:
15349 
  """
15350 
  Attributes:
15351 
   - orderId
15352 
   - isAuthorized
15353 
  """
15354 
 
15355 
  thrift_spec = (
15356 
    None, # 0
15357 
    (1, TType.I64, 'orderId', None, None, ), # 1
15358 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
15359 
  )
15360 
 
15361 
  def __init__(self, orderId=None, isAuthorized=None,):
15362 
    self.orderId = orderId
15363 
    self.isAuthorized = isAuthorized
15364 
 
15365 
  def read(self, iprot):
15366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15368 
      return
15369 
    iprot.readStructBegin()
15370 
    while True:
15371 
      (fname, ftype, fid) = iprot.readFieldBegin()
15372 
      if ftype == TType.STOP:
15373 
        break
15374 
      if fid == 1:
15375 
        if ftype == TType.I64:
15376 
          self.orderId = iprot.readI64();
15377 
        else:
15378 
          iprot.skip(ftype)
15379 
      elif fid == 2:
15380 
        if ftype == TType.BOOL:
15381 
          self.isAuthorized = iprot.readBool();
15382 
        else:
15383 
          iprot.skip(ftype)
15384 
      else:
15385 
        iprot.skip(ftype)
15386 
      iprot.readFieldEnd()
15387 
    iprot.readStructEnd()
15388 
 
15389 
  def write(self, oprot):
15390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15392 
      return
15393 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
15394 
    if self.orderId is not None:
15395 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15396 
      oprot.writeI64(self.orderId)
15397 
      oprot.writeFieldEnd()
15398 
    if self.isAuthorized is not None:
15399 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
15400 
      oprot.writeBool(self.isAuthorized)
15401 
      oprot.writeFieldEnd()
15402 
    oprot.writeFieldStop()
15403 
    oprot.writeStructEnd()
15404 
 
15405 
  def validate(self):
15406 
    return
15407 
 
15408 
 
15409 
  def __repr__(self):
15410 
    L = ['%s=%r' % (key, value)
15411 
      for key, value in self.__dict__.iteritems()]
15412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15413 
 
15414 
  def __eq__(self, other):
15415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15416 
 
15417 
  def __ne__(self, other):
15418 
    return not (self == other)
15419 
 
15420 
class markOrderDoaRequestAuthorized_result:
15421 
  """
15422 
  Attributes:
15423 
   - success
15424 
   - ex
15425 
  """
15426 
 
15427 
  thrift_spec = (
15428 
    (0, TType.BOOL, 'success', None, None, ), # 0
15429 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15430 
  )
15431 
 
15432 
  def __init__(self, success=None, ex=None,):
15433 
    self.success = success
15434 
    self.ex = ex
15435 
 
15436 
  def read(self, iprot):
15437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15439 
      return
15440 
    iprot.readStructBegin()
15441 
    while True:
15442 
      (fname, ftype, fid) = iprot.readFieldBegin()
15443 
      if ftype == TType.STOP:
15444 
        break
15445 
      if fid == 0:
15446 
        if ftype == TType.BOOL:
15447 
          self.success = iprot.readBool();
15448 
        else:
15449 
          iprot.skip(ftype)
15450 
      elif fid == 1:
15451 
        if ftype == TType.STRUCT:
15452 
          self.ex = TransactionServiceException()
15453 
          self.ex.read(iprot)
15454 
        else:
15455 
          iprot.skip(ftype)
15456 
      else:
15457 
        iprot.skip(ftype)
15458 
      iprot.readFieldEnd()
15459 
    iprot.readStructEnd()
15460 
 
15461 
  def write(self, oprot):
15462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15464 
      return
15465 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
15466 
    if self.success is not None:
15467 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15468 
      oprot.writeBool(self.success)
15469 
      oprot.writeFieldEnd()
15470 
    if self.ex is not None:
15471 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15472 
      self.ex.write(oprot)
15473 
      oprot.writeFieldEnd()
15474 
    oprot.writeFieldStop()
15475 
    oprot.writeStructEnd()
15476 
 
15477 
  def validate(self):
15478 
    return
15479 
 
15480 
 
15481 
  def __repr__(self):
15482 
    L = ['%s=%r' % (key, value)
15483 
      for key, value in self.__dict__.iteritems()]
15484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15485 
 
15486 
  def __eq__(self, other):
15487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15488 
 
15489 
  def __ne__(self, other):
15490 
    return not (self == other)
15491 
 
4488 rajveer 15492 
class markOrderReturnRequestReceived_args:
15493 
  """
15494 
  Attributes:
15495 
   - orderId
15496 
  """
15497 
 
15498 
  thrift_spec = (
15499 
    None, # 0
15500 
    (1, TType.I64, 'orderId', None, None, ), # 1
15501 
  )
15502 
 
15503 
  def __init__(self, orderId=None,):
15504 
    self.orderId = orderId
15505 
 
15506 
  def read(self, iprot):
15507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15509 
      return
15510 
    iprot.readStructBegin()
15511 
    while True:
15512 
      (fname, ftype, fid) = iprot.readFieldBegin()
15513 
      if ftype == TType.STOP:
15514 
        break
15515 
      if fid == 1:
15516 
        if ftype == TType.I64:
15517 
          self.orderId = iprot.readI64();
15518 
        else:
15519 
          iprot.skip(ftype)
15520 
      else:
15521 
        iprot.skip(ftype)
15522 
      iprot.readFieldEnd()
15523 
    iprot.readStructEnd()
15524 
 
15525 
  def write(self, oprot):
15526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15528 
      return
15529 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
15530 
    if self.orderId is not None:
15531 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15532 
      oprot.writeI64(self.orderId)
15533 
      oprot.writeFieldEnd()
15534 
    oprot.writeFieldStop()
15535 
    oprot.writeStructEnd()
15536 
 
15537 
  def validate(self):
15538 
    return
15539 
 
15540 
 
15541 
  def __repr__(self):
15542 
    L = ['%s=%r' % (key, value)
15543 
      for key, value in self.__dict__.iteritems()]
15544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15545 
 
15546 
  def __eq__(self, other):
15547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15548 
 
15549 
  def __ne__(self, other):
15550 
    return not (self == other)
15551 
 
15552 
class markOrderReturnRequestReceived_result:
15553 
  """
15554 
  Attributes:
15555 
   - success
15556 
   - ex
15557 
  """
15558 
 
15559 
  thrift_spec = (
15560 
    (0, TType.BOOL, 'success', None, None, ), # 0
15561 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15562 
  )
15563 
 
15564 
  def __init__(self, success=None, ex=None,):
15565 
    self.success = success
15566 
    self.ex = ex
15567 
 
15568 
  def read(self, iprot):
15569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15571 
      return
15572 
    iprot.readStructBegin()
15573 
    while True:
15574 
      (fname, ftype, fid) = iprot.readFieldBegin()
15575 
      if ftype == TType.STOP:
15576 
        break
15577 
      if fid == 0:
15578 
        if ftype == TType.BOOL:
15579 
          self.success = iprot.readBool();
15580 
        else:
15581 
          iprot.skip(ftype)
15582 
      elif fid == 1:
15583 
        if ftype == TType.STRUCT:
15584 
          self.ex = TransactionServiceException()
15585 
          self.ex.read(iprot)
15586 
        else:
15587 
          iprot.skip(ftype)
15588 
      else:
15589 
        iprot.skip(ftype)
15590 
      iprot.readFieldEnd()
15591 
    iprot.readStructEnd()
15592 
 
15593 
  def write(self, oprot):
15594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15596 
      return
15597 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
15598 
    if self.success is not None:
15599 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15600 
      oprot.writeBool(self.success)
15601 
      oprot.writeFieldEnd()
15602 
    if self.ex is not None:
15603 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15604 
      self.ex.write(oprot)
15605 
      oprot.writeFieldEnd()
15606 
    oprot.writeFieldStop()
15607 
    oprot.writeStructEnd()
15608 
 
15609 
  def validate(self):
15610 
    return
15611 
 
15612 
 
15613 
  def __repr__(self):
15614 
    L = ['%s=%r' % (key, value)
15615 
      for key, value in self.__dict__.iteritems()]
15616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15617 
 
15618 
  def __eq__(self, other):
15619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15620 
 
15621 
  def __ne__(self, other):
15622 
    return not (self == other)
15623 
 
15624 
class markOrderReturnRequestAuthorized_args:
15625 
  """
15626 
  Attributes:
15627 
   - orderId
15628 
   - isAuthorized
15629 
  """
15630 
 
15631 
  thrift_spec = (
15632 
    None, # 0
15633 
    (1, TType.I64, 'orderId', None, None, ), # 1
15634 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
15635 
  )
15636 
 
15637 
  def __init__(self, orderId=None, isAuthorized=None,):
15638 
    self.orderId = orderId
15639 
    self.isAuthorized = isAuthorized
15640 
 
15641 
  def read(self, iprot):
15642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15644 
      return
15645 
    iprot.readStructBegin()
15646 
    while True:
15647 
      (fname, ftype, fid) = iprot.readFieldBegin()
15648 
      if ftype == TType.STOP:
15649 
        break
15650 
      if fid == 1:
15651 
        if ftype == TType.I64:
15652 
          self.orderId = iprot.readI64();
15653 
        else:
15654 
          iprot.skip(ftype)
15655 
      elif fid == 2:
15656 
        if ftype == TType.BOOL:
15657 
          self.isAuthorized = iprot.readBool();
15658 
        else:
15659 
          iprot.skip(ftype)
15660 
      else:
15661 
        iprot.skip(ftype)
15662 
      iprot.readFieldEnd()
15663 
    iprot.readStructEnd()
15664 
 
15665 
  def write(self, oprot):
15666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15668 
      return
15669 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
15670 
    if self.orderId is not None:
15671 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15672 
      oprot.writeI64(self.orderId)
15673 
      oprot.writeFieldEnd()
15674 
    if self.isAuthorized is not None:
15675 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
15676 
      oprot.writeBool(self.isAuthorized)
15677 
      oprot.writeFieldEnd()
15678 
    oprot.writeFieldStop()
15679 
    oprot.writeStructEnd()
15680 
 
15681 
  def validate(self):
15682 
    return
15683 
 
15684 
 
15685 
  def __repr__(self):
15686 
    L = ['%s=%r' % (key, value)
15687 
      for key, value in self.__dict__.iteritems()]
15688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15689 
 
15690 
  def __eq__(self, other):
15691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15692 
 
15693 
  def __ne__(self, other):
15694 
    return not (self == other)
15695 
 
15696 
class markOrderReturnRequestAuthorized_result:
15697 
  """
15698 
  Attributes:
15699 
   - success
15700 
   - ex
15701 
  """
15702 
 
15703 
  thrift_spec = (
15704 
    (0, TType.BOOL, 'success', None, None, ), # 0
15705 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15706 
  )
15707 
 
15708 
  def __init__(self, success=None, ex=None,):
15709 
    self.success = success
15710 
    self.ex = ex
15711 
 
15712 
  def read(self, iprot):
15713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15715 
      return
15716 
    iprot.readStructBegin()
15717 
    while True:
15718 
      (fname, ftype, fid) = iprot.readFieldBegin()
15719 
      if ftype == TType.STOP:
15720 
        break
15721 
      if fid == 0:
15722 
        if ftype == TType.BOOL:
15723 
          self.success = iprot.readBool();
15724 
        else:
15725 
          iprot.skip(ftype)
15726 
      elif fid == 1:
15727 
        if ftype == TType.STRUCT:
15728 
          self.ex = TransactionServiceException()
15729 
          self.ex.read(iprot)
15730 
        else:
15731 
          iprot.skip(ftype)
15732 
      else:
15733 
        iprot.skip(ftype)
15734 
      iprot.readFieldEnd()
15735 
    iprot.readStructEnd()
15736 
 
15737 
  def write(self, oprot):
15738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15740 
      return
15741 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
15742 
    if self.success is not None:
15743 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15744 
      oprot.writeBool(self.success)
15745 
      oprot.writeFieldEnd()
15746 
    if self.ex is not None:
15747 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15748 
      self.ex.write(oprot)
15749 
      oprot.writeFieldEnd()
15750 
    oprot.writeFieldStop()
15751 
    oprot.writeStructEnd()
15752 
 
15753 
  def validate(self):
15754 
    return
15755 
 
15756 
 
15757 
  def __repr__(self):
15758 
    L = ['%s=%r' % (key, value)
15759 
      for key, value in self.__dict__.iteritems()]
15760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15761 
 
15762 
  def __eq__(self, other):
15763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15764 
 
15765 
  def __ne__(self, other):
15766 
    return not (self == other)
15767 
 
2536 chandransh 15768 
class requestPickupNumber_args:
15769 
  """
15770 
  Attributes:
15771 
   - orderId
4579 rajveer 15772 
   - providerId
2536 chandransh 15773 
  """
15774 
 
15775 
  thrift_spec = (
15776 
    None, # 0
15777 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 15778 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 15779 
  )
15780 
 
4579 rajveer 15781 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 15782 
    self.orderId = orderId
4579 rajveer 15783 
    self.providerId = providerId
2536 chandransh 15784 
 
15785 
  def read(self, iprot):
15786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15788 
      return
15789 
    iprot.readStructBegin()
15790 
    while True:
15791 
      (fname, ftype, fid) = iprot.readFieldBegin()
15792 
      if ftype == TType.STOP:
15793 
        break
15794 
      if fid == 1:
15795 
        if ftype == TType.I64:
15796 
          self.orderId = iprot.readI64();
15797 
        else:
15798 
          iprot.skip(ftype)
4579 rajveer 15799 
      elif fid == 2:
15800 
        if ftype == TType.I64:
15801 
          self.providerId = iprot.readI64();
15802 
        else:
15803 
          iprot.skip(ftype)
2536 chandransh 15804 
      else:
15805 
        iprot.skip(ftype)
15806 
      iprot.readFieldEnd()
15807 
    iprot.readStructEnd()
15808 
 
15809 
  def write(self, oprot):
15810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15812 
      return
15813 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 15814 
    if self.orderId is not None:
2536 chandransh 15815 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15816 
      oprot.writeI64(self.orderId)
15817 
      oprot.writeFieldEnd()
4579 rajveer 15818 
    if self.providerId is not None:
15819 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
15820 
      oprot.writeI64(self.providerId)
15821 
      oprot.writeFieldEnd()
2536 chandransh 15822 
    oprot.writeFieldStop()
15823 
    oprot.writeStructEnd()
15824 
 
3431 rajveer 15825 
  def validate(self):
15826 
    return
15827 
 
15828 
 
2536 chandransh 15829 
  def __repr__(self):
15830 
    L = ['%s=%r' % (key, value)
15831 
      for key, value in self.__dict__.iteritems()]
15832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15833 
 
15834 
  def __eq__(self, other):
15835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15836 
 
15837 
  def __ne__(self, other):
15838 
    return not (self == other)
15839 
 
15840 
class requestPickupNumber_result:
15841 
  """
15842 
  Attributes:
15843 
   - success
15844 
   - ex
15845 
  """
15846 
 
15847 
  thrift_spec = (
15848 
    (0, TType.BOOL, 'success', None, None, ), # 0
15849 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15850 
  )
15851 
 
15852 
  def __init__(self, success=None, ex=None,):
15853 
    self.success = success
15854 
    self.ex = ex
15855 
 
15856 
  def read(self, iprot):
15857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15859 
      return
15860 
    iprot.readStructBegin()
15861 
    while True:
15862 
      (fname, ftype, fid) = iprot.readFieldBegin()
15863 
      if ftype == TType.STOP:
15864 
        break
15865 
      if fid == 0:
15866 
        if ftype == TType.BOOL:
15867 
          self.success = iprot.readBool();
15868 
        else:
15869 
          iprot.skip(ftype)
15870 
      elif fid == 1:
15871 
        if ftype == TType.STRUCT:
15872 
          self.ex = TransactionServiceException()
15873 
          self.ex.read(iprot)
15874 
        else:
15875 
          iprot.skip(ftype)
15876 
      else:
15877 
        iprot.skip(ftype)
15878 
      iprot.readFieldEnd()
15879 
    iprot.readStructEnd()
15880 
 
15881 
  def write(self, oprot):
15882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15884 
      return
15885 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 15886 
    if self.success is not None:
2536 chandransh 15887 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15888 
      oprot.writeBool(self.success)
15889 
      oprot.writeFieldEnd()
3431 rajveer 15890 
    if self.ex is not None:
2536 chandransh 15891 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15892 
      self.ex.write(oprot)
15893 
      oprot.writeFieldEnd()
15894 
    oprot.writeFieldStop()
15895 
    oprot.writeStructEnd()
15896 
 
3431 rajveer 15897 
  def validate(self):
15898 
    return
15899 
 
15900 
 
2536 chandransh 15901 
  def __repr__(self):
15902 
    L = ['%s=%r' % (key, value)
15903 
      for key, value in self.__dict__.iteritems()]
15904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15905 
 
15906 
  def __eq__(self, other):
15907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15908 
 
15909 
  def __ne__(self, other):
15910 
    return not (self == other)
15911 
 
15912 
class authorizePickup_args:
15913 
  """
15914 
  Attributes:
15915 
   - orderId
15916 
   - pickupNumber
4602 rajveer 15917 
   - providerId
2536 chandransh 15918 
  """
15919 
 
15920 
  thrift_spec = (
15921 
    None, # 0
15922 
    (1, TType.I64, 'orderId', None, None, ), # 1
15923 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 15924 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 15925 
  )
15926 
 
4602 rajveer 15927 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 15928 
    self.orderId = orderId
15929 
    self.pickupNumber = pickupNumber
4602 rajveer 15930 
    self.providerId = providerId
2536 chandransh 15931 
 
15932 
  def read(self, iprot):
15933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15935 
      return
15936 
    iprot.readStructBegin()
15937 
    while True:
15938 
      (fname, ftype, fid) = iprot.readFieldBegin()
15939 
      if ftype == TType.STOP:
15940 
        break
15941 
      if fid == 1:
15942 
        if ftype == TType.I64:
15943 
          self.orderId = iprot.readI64();
15944 
        else:
15945 
          iprot.skip(ftype)
15946 
      elif fid == 2:
15947 
        if ftype == TType.STRING:
15948 
          self.pickupNumber = iprot.readString();
15949 
        else:
15950 
          iprot.skip(ftype)
4602 rajveer 15951 
      elif fid == 3:
15952 
        if ftype == TType.I64:
15953 
          self.providerId = iprot.readI64();
15954 
        else:
15955 
          iprot.skip(ftype)
2536 chandransh 15956 
      else:
15957 
        iprot.skip(ftype)
15958 
      iprot.readFieldEnd()
15959 
    iprot.readStructEnd()
15960 
 
15961 
  def write(self, oprot):
15962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15964 
      return
15965 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 15966 
    if self.orderId is not None:
2536 chandransh 15967 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15968 
      oprot.writeI64(self.orderId)
15969 
      oprot.writeFieldEnd()
3431 rajveer 15970 
    if self.pickupNumber is not None:
2536 chandransh 15971 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
15972 
      oprot.writeString(self.pickupNumber)
15973 
      oprot.writeFieldEnd()
4602 rajveer 15974 
    if self.providerId is not None:
15975 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
15976 
      oprot.writeI64(self.providerId)
15977 
      oprot.writeFieldEnd()
2536 chandransh 15978 
    oprot.writeFieldStop()
15979 
    oprot.writeStructEnd()
15980 
 
3431 rajveer 15981 
  def validate(self):
15982 
    return
15983 
 
15984 
 
2536 chandransh 15985 
  def __repr__(self):
15986 
    L = ['%s=%r' % (key, value)
15987 
      for key, value in self.__dict__.iteritems()]
15988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15989 
 
15990 
  def __eq__(self, other):
15991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15992 
 
15993 
  def __ne__(self, other):
15994 
    return not (self == other)
15995 
 
15996 
class authorizePickup_result:
15997 
  """
15998 
  Attributes:
15999 
   - success
16000 
   - ex
16001 
  """
16002 
 
16003 
  thrift_spec = (
16004 
    (0, TType.BOOL, 'success', None, None, ), # 0
16005 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16006 
  )
16007 
 
16008 
  def __init__(self, success=None, ex=None,):
16009 
    self.success = success
16010 
    self.ex = ex
16011 
 
16012 
  def read(self, iprot):
16013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16015 
      return
16016 
    iprot.readStructBegin()
16017 
    while True:
16018 
      (fname, ftype, fid) = iprot.readFieldBegin()
16019 
      if ftype == TType.STOP:
16020 
        break
16021 
      if fid == 0:
16022 
        if ftype == TType.BOOL:
16023 
          self.success = iprot.readBool();
16024 
        else:
16025 
          iprot.skip(ftype)
16026 
      elif fid == 1:
16027 
        if ftype == TType.STRUCT:
16028 
          self.ex = TransactionServiceException()
16029 
          self.ex.read(iprot)
16030 
        else:
16031 
          iprot.skip(ftype)
16032 
      else:
16033 
        iprot.skip(ftype)
16034 
      iprot.readFieldEnd()
16035 
    iprot.readStructEnd()
16036 
 
16037 
  def write(self, oprot):
16038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16040 
      return
16041 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 16042 
    if self.success is not None:
2536 chandransh 16043 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16044 
      oprot.writeBool(self.success)
16045 
      oprot.writeFieldEnd()
3431 rajveer 16046 
    if self.ex is not None:
2536 chandransh 16047 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16048 
      self.ex.write(oprot)
16049 
      oprot.writeFieldEnd()
16050 
    oprot.writeFieldStop()
16051 
    oprot.writeStructEnd()
16052 
 
3431 rajveer 16053 
  def validate(self):
16054 
    return
16055 
 
16056 
 
2536 chandransh 16057 
  def __repr__(self):
16058 
    L = ['%s=%r' % (key, value)
16059 
      for key, value in self.__dict__.iteritems()]
16060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16061 
 
16062 
  def __eq__(self, other):
16063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16064 
 
16065 
  def __ne__(self, other):
16066 
    return not (self == other)
16067 
 
2764 chandransh 16068 
class markDoasAsPickedUp_args:
16069 
  """
16070 
  Attributes:
16071 
   - providerId
16072 
   - pickupDetails
16073 
  """
16074 
 
16075 
  thrift_spec = (
16076 
    None, # 0
16077 
    (1, TType.I64, 'providerId', None, None, ), # 1
16078 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16079 
  )
16080 
 
16081 
  def __init__(self, providerId=None, pickupDetails=None,):
16082 
    self.providerId = providerId
16083 
    self.pickupDetails = pickupDetails
16084 
 
16085 
  def read(self, iprot):
16086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16088 
      return
16089 
    iprot.readStructBegin()
16090 
    while True:
16091 
      (fname, ftype, fid) = iprot.readFieldBegin()
16092 
      if ftype == TType.STOP:
16093 
        break
16094 
      if fid == 1:
16095 
        if ftype == TType.I64:
16096 
          self.providerId = iprot.readI64();
16097 
        else:
16098 
          iprot.skip(ftype)
16099 
      elif fid == 2:
16100 
        if ftype == TType.MAP:
16101 
          self.pickupDetails = {}
5713 rajveer 16102 
          (_ktype365, _vtype366, _size364 ) = iprot.readMapBegin()
16103 
          for _i368 in xrange(_size364):
16104 
            _key369 = iprot.readString();
16105 
            _val370 = iprot.readString();
16106 
            self.pickupDetails[_key369] = _val370
2764 chandransh 16107 
          iprot.readMapEnd()
16108 
        else:
16109 
          iprot.skip(ftype)
16110 
      else:
16111 
        iprot.skip(ftype)
16112 
      iprot.readFieldEnd()
16113 
    iprot.readStructEnd()
16114 
 
16115 
  def write(self, oprot):
16116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16118 
      return
16119 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 16120 
    if self.providerId is not None:
2764 chandransh 16121 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16122 
      oprot.writeI64(self.providerId)
16123 
      oprot.writeFieldEnd()
3431 rajveer 16124 
    if self.pickupDetails is not None:
2764 chandransh 16125 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16126 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5713 rajveer 16127 
      for kiter371,viter372 in self.pickupDetails.items():
16128 
        oprot.writeString(kiter371)
16129 
        oprot.writeString(viter372)
2764 chandransh 16130 
      oprot.writeMapEnd()
16131 
      oprot.writeFieldEnd()
16132 
    oprot.writeFieldStop()
16133 
    oprot.writeStructEnd()
16134 
 
3431 rajveer 16135 
  def validate(self):
16136 
    return
16137 
 
16138 
 
2764 chandransh 16139 
  def __repr__(self):
16140 
    L = ['%s=%r' % (key, value)
16141 
      for key, value in self.__dict__.iteritems()]
16142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16143 
 
16144 
  def __eq__(self, other):
16145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16146 
 
16147 
  def __ne__(self, other):
16148 
    return not (self == other)
16149 
 
16150 
class markDoasAsPickedUp_result:
4910 phani.kuma 16151 
 
16152 
  thrift_spec = (
16153 
  )
16154 
 
16155 
  def read(self, iprot):
16156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16158 
      return
16159 
    iprot.readStructBegin()
16160 
    while True:
16161 
      (fname, ftype, fid) = iprot.readFieldBegin()
16162 
      if ftype == TType.STOP:
16163 
        break
16164 
      else:
16165 
        iprot.skip(ftype)
16166 
      iprot.readFieldEnd()
16167 
    iprot.readStructEnd()
16168 
 
16169 
  def write(self, oprot):
16170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16172 
      return
16173 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
16174 
    oprot.writeFieldStop()
16175 
    oprot.writeStructEnd()
16176 
 
16177 
  def validate(self):
16178 
    return
16179 
 
16180 
 
16181 
  def __repr__(self):
16182 
    L = ['%s=%r' % (key, value)
16183 
      for key, value in self.__dict__.iteritems()]
16184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16185 
 
16186 
  def __eq__(self, other):
16187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16188 
 
16189 
  def __ne__(self, other):
16190 
    return not (self == other)
16191 
 
16192 
class getDoasNotPickedUp_args:
2764 chandransh 16193 
  """
16194 
  Attributes:
4910 phani.kuma 16195 
   - providerId
16196 
  """
16197 
 
16198 
  thrift_spec = (
16199 
    None, # 0
16200 
    (1, TType.I64, 'providerId', None, None, ), # 1
16201 
  )
16202 
 
16203 
  def __init__(self, providerId=None,):
16204 
    self.providerId = providerId
16205 
 
16206 
  def read(self, iprot):
16207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16209 
      return
16210 
    iprot.readStructBegin()
16211 
    while True:
16212 
      (fname, ftype, fid) = iprot.readFieldBegin()
16213 
      if ftype == TType.STOP:
16214 
        break
16215 
      if fid == 1:
16216 
        if ftype == TType.I64:
16217 
          self.providerId = iprot.readI64();
16218 
        else:
16219 
          iprot.skip(ftype)
16220 
      else:
16221 
        iprot.skip(ftype)
16222 
      iprot.readFieldEnd()
16223 
    iprot.readStructEnd()
16224 
 
16225 
  def write(self, oprot):
16226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16228 
      return
16229 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
16230 
    if self.providerId is not None:
16231 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16232 
      oprot.writeI64(self.providerId)
16233 
      oprot.writeFieldEnd()
16234 
    oprot.writeFieldStop()
16235 
    oprot.writeStructEnd()
16236 
 
16237 
  def validate(self):
16238 
    return
16239 
 
16240 
 
16241 
  def __repr__(self):
16242 
    L = ['%s=%r' % (key, value)
16243 
      for key, value in self.__dict__.iteritems()]
16244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16245 
 
16246 
  def __eq__(self, other):
16247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16248 
 
16249 
  def __ne__(self, other):
16250 
    return not (self == other)
16251 
 
16252 
class getDoasNotPickedUp_result:
16253 
  """
16254 
  Attributes:
2764 chandransh 16255 
   - success
16256 
  """
16257 
 
16258 
  thrift_spec = (
16259 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16260 
  )
16261 
 
16262 
  def __init__(self, success=None,):
16263 
    self.success = success
16264 
 
16265 
  def read(self, iprot):
16266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16268 
      return
16269 
    iprot.readStructBegin()
16270 
    while True:
16271 
      (fname, ftype, fid) = iprot.readFieldBegin()
16272 
      if ftype == TType.STOP:
16273 
        break
16274 
      if fid == 0:
16275 
        if ftype == TType.LIST:
16276 
          self.success = []
5713 rajveer 16277 
          (_etype376, _size373) = iprot.readListBegin()
16278 
          for _i377 in xrange(_size373):
16279 
            _elem378 = Order()
16280 
            _elem378.read(iprot)
16281 
            self.success.append(_elem378)
2764 chandransh 16282 
          iprot.readListEnd()
16283 
        else:
16284 
          iprot.skip(ftype)
16285 
      else:
16286 
        iprot.skip(ftype)
16287 
      iprot.readFieldEnd()
16288 
    iprot.readStructEnd()
16289 
 
16290 
  def write(self, oprot):
16291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16293 
      return
4910 phani.kuma 16294 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 16295 
    if self.success is not None:
2764 chandransh 16296 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16297 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 16298 
      for iter379 in self.success:
16299 
        iter379.write(oprot)
2764 chandransh 16300 
      oprot.writeListEnd()
16301 
      oprot.writeFieldEnd()
16302 
    oprot.writeFieldStop()
16303 
    oprot.writeStructEnd()
16304 
 
3431 rajveer 16305 
  def validate(self):
16306 
    return
16307 
 
16308 
 
2764 chandransh 16309 
  def __repr__(self):
16310 
    L = ['%s=%r' % (key, value)
16311 
      for key, value in self.__dict__.iteritems()]
16312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16313 
 
16314 
  def __eq__(self, other):
16315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16316 
 
16317 
  def __ne__(self, other):
16318 
    return not (self == other)
16319 
 
4741 phani.kuma 16320 
class markReturnOrdersAsPickedUp_args:
16321 
  """
16322 
  Attributes:
16323 
   - providerId
16324 
   - pickupDetails
16325 
  """
16326 
 
16327 
  thrift_spec = (
16328 
    None, # 0
16329 
    (1, TType.I64, 'providerId', None, None, ), # 1
16330 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16331 
  )
16332 
 
16333 
  def __init__(self, providerId=None, pickupDetails=None,):
16334 
    self.providerId = providerId
16335 
    self.pickupDetails = pickupDetails
16336 
 
16337 
  def read(self, iprot):
16338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16340 
      return
16341 
    iprot.readStructBegin()
16342 
    while True:
16343 
      (fname, ftype, fid) = iprot.readFieldBegin()
16344 
      if ftype == TType.STOP:
16345 
        break
16346 
      if fid == 1:
16347 
        if ftype == TType.I64:
16348 
          self.providerId = iprot.readI64();
16349 
        else:
16350 
          iprot.skip(ftype)
16351 
      elif fid == 2:
16352 
        if ftype == TType.MAP:
16353 
          self.pickupDetails = {}
5713 rajveer 16354 
          (_ktype381, _vtype382, _size380 ) = iprot.readMapBegin()
16355 
          for _i384 in xrange(_size380):
16356 
            _key385 = iprot.readString();
16357 
            _val386 = iprot.readString();
16358 
            self.pickupDetails[_key385] = _val386
4741 phani.kuma 16359 
          iprot.readMapEnd()
16360 
        else:
16361 
          iprot.skip(ftype)
16362 
      else:
16363 
        iprot.skip(ftype)
16364 
      iprot.readFieldEnd()
16365 
    iprot.readStructEnd()
16366 
 
16367 
  def write(self, oprot):
16368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16370 
      return
16371 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
16372 
    if self.providerId is not None:
16373 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16374 
      oprot.writeI64(self.providerId)
16375 
      oprot.writeFieldEnd()
16376 
    if self.pickupDetails is not None:
16377 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16378 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
5713 rajveer 16379 
      for kiter387,viter388 in self.pickupDetails.items():
16380 
        oprot.writeString(kiter387)
16381 
        oprot.writeString(viter388)
4741 phani.kuma 16382 
      oprot.writeMapEnd()
16383 
      oprot.writeFieldEnd()
16384 
    oprot.writeFieldStop()
16385 
    oprot.writeStructEnd()
16386 
 
16387 
  def validate(self):
16388 
    return
16389 
 
16390 
 
16391 
  def __repr__(self):
16392 
    L = ['%s=%r' % (key, value)
16393 
      for key, value in self.__dict__.iteritems()]
16394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16395 
 
16396 
  def __eq__(self, other):
16397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16398 
 
16399 
  def __ne__(self, other):
16400 
    return not (self == other)
16401 
 
16402 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 16403 
 
16404 
  thrift_spec = (
16405 
  )
16406 
 
16407 
  def read(self, iprot):
16408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16410 
      return
16411 
    iprot.readStructBegin()
16412 
    while True:
16413 
      (fname, ftype, fid) = iprot.readFieldBegin()
16414 
      if ftype == TType.STOP:
16415 
        break
16416 
      else:
16417 
        iprot.skip(ftype)
16418 
      iprot.readFieldEnd()
16419 
    iprot.readStructEnd()
16420 
 
16421 
  def write(self, oprot):
16422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16424 
      return
16425 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
16426 
    oprot.writeFieldStop()
16427 
    oprot.writeStructEnd()
16428 
 
16429 
  def validate(self):
16430 
    return
16431 
 
16432 
 
16433 
  def __repr__(self):
16434 
    L = ['%s=%r' % (key, value)
16435 
      for key, value in self.__dict__.iteritems()]
16436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16437 
 
16438 
  def __eq__(self, other):
16439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16440 
 
16441 
  def __ne__(self, other):
16442 
    return not (self == other)
16443 
 
16444 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 16445 
  """
16446 
  Attributes:
4910 phani.kuma 16447 
   - providerId
16448 
  """
16449 
 
16450 
  thrift_spec = (
16451 
    None, # 0
16452 
    (1, TType.I64, 'providerId', None, None, ), # 1
16453 
  )
16454 
 
16455 
  def __init__(self, providerId=None,):
16456 
    self.providerId = providerId
16457 
 
16458 
  def read(self, iprot):
16459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16461 
      return
16462 
    iprot.readStructBegin()
16463 
    while True:
16464 
      (fname, ftype, fid) = iprot.readFieldBegin()
16465 
      if ftype == TType.STOP:
16466 
        break
16467 
      if fid == 1:
16468 
        if ftype == TType.I64:
16469 
          self.providerId = iprot.readI64();
16470 
        else:
16471 
          iprot.skip(ftype)
16472 
      else:
16473 
        iprot.skip(ftype)
16474 
      iprot.readFieldEnd()
16475 
    iprot.readStructEnd()
16476 
 
16477 
  def write(self, oprot):
16478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16480 
      return
16481 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
16482 
    if self.providerId is not None:
16483 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16484 
      oprot.writeI64(self.providerId)
16485 
      oprot.writeFieldEnd()
16486 
    oprot.writeFieldStop()
16487 
    oprot.writeStructEnd()
16488 
 
16489 
  def validate(self):
16490 
    return
16491 
 
16492 
 
16493 
  def __repr__(self):
16494 
    L = ['%s=%r' % (key, value)
16495 
      for key, value in self.__dict__.iteritems()]
16496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16497 
 
16498 
  def __eq__(self, other):
16499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16500 
 
16501 
  def __ne__(self, other):
16502 
    return not (self == other)
16503 
 
16504 
class getReturnOrdersNotPickedUp_result:
16505 
  """
16506 
  Attributes:
4741 phani.kuma 16507 
   - success
16508 
  """
16509 
 
16510 
  thrift_spec = (
16511 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16512 
  )
16513 
 
16514 
  def __init__(self, success=None,):
16515 
    self.success = success
16516 
 
16517 
  def read(self, iprot):
16518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16520 
      return
16521 
    iprot.readStructBegin()
16522 
    while True:
16523 
      (fname, ftype, fid) = iprot.readFieldBegin()
16524 
      if ftype == TType.STOP:
16525 
        break
16526 
      if fid == 0:
16527 
        if ftype == TType.LIST:
16528 
          self.success = []
5713 rajveer 16529 
          (_etype392, _size389) = iprot.readListBegin()
16530 
          for _i393 in xrange(_size389):
16531 
            _elem394 = Order()
16532 
            _elem394.read(iprot)
16533 
            self.success.append(_elem394)
4741 phani.kuma 16534 
          iprot.readListEnd()
16535 
        else:
16536 
          iprot.skip(ftype)
16537 
      else:
16538 
        iprot.skip(ftype)
16539 
      iprot.readFieldEnd()
16540 
    iprot.readStructEnd()
16541 
 
16542 
  def write(self, oprot):
16543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16545 
      return
4910 phani.kuma 16546 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 16547 
    if self.success is not None:
16548 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16549 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 16550 
      for iter395 in self.success:
16551 
        iter395.write(oprot)
4741 phani.kuma 16552 
      oprot.writeListEnd()
16553 
      oprot.writeFieldEnd()
16554 
    oprot.writeFieldStop()
16555 
    oprot.writeStructEnd()
16556 
 
16557 
  def validate(self):
16558 
    return
16559 
 
16560 
 
16561 
  def __repr__(self):
16562 
    L = ['%s=%r' % (key, value)
16563 
      for key, value in self.__dict__.iteritems()]
16564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16565 
 
16566 
  def __eq__(self, other):
16567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16568 
 
16569 
  def __ne__(self, other):
16570 
    return not (self == other)
16571 
 
2616 chandransh 16572 
class receiveReturn_args:
2591 chandransh 16573 
  """
16574 
  Attributes:
16575 
   - orderId
4479 rajveer 16576 
   - receiveCondition
2591 chandransh 16577 
  """
2536 chandransh 16578 
 
2591 chandransh 16579 
  thrift_spec = (
16580 
    None, # 0
16581 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 16582 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 16583 
  )
16584 
 
4479 rajveer 16585 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 16586 
    self.orderId = orderId
4479 rajveer 16587 
    self.receiveCondition = receiveCondition
2591 chandransh 16588 
 
16589 
  def read(self, iprot):
16590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16592 
      return
16593 
    iprot.readStructBegin()
16594 
    while True:
16595 
      (fname, ftype, fid) = iprot.readFieldBegin()
16596 
      if ftype == TType.STOP:
16597 
        break
16598 
      if fid == 1:
16599 
        if ftype == TType.I64:
16600 
          self.orderId = iprot.readI64();
16601 
        else:
16602 
          iprot.skip(ftype)
4479 rajveer 16603 
      elif fid == 2:
16604 
        if ftype == TType.I64:
16605 
          self.receiveCondition = iprot.readI64();
16606 
        else:
16607 
          iprot.skip(ftype)
2591 chandransh 16608 
      else:
16609 
        iprot.skip(ftype)
16610 
      iprot.readFieldEnd()
16611 
    iprot.readStructEnd()
16612 
 
16613 
  def write(self, oprot):
16614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16616 
      return
2616 chandransh 16617 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 16618 
    if self.orderId is not None:
2591 chandransh 16619 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16620 
      oprot.writeI64(self.orderId)
16621 
      oprot.writeFieldEnd()
4479 rajveer 16622 
    if self.receiveCondition is not None:
16623 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
16624 
      oprot.writeI64(self.receiveCondition)
16625 
      oprot.writeFieldEnd()
2591 chandransh 16626 
    oprot.writeFieldStop()
16627 
    oprot.writeStructEnd()
16628 
 
3431 rajveer 16629 
  def validate(self):
16630 
    return
16631 
 
16632 
 
2591 chandransh 16633 
  def __repr__(self):
16634 
    L = ['%s=%r' % (key, value)
16635 
      for key, value in self.__dict__.iteritems()]
16636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16637 
 
16638 
  def __eq__(self, other):
16639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16640 
 
16641 
  def __ne__(self, other):
16642 
    return not (self == other)
16643 
 
2616 chandransh 16644 
class receiveReturn_result:
2591 chandransh 16645 
  """
16646 
  Attributes:
16647 
   - success
16648 
   - ex
16649 
  """
16650 
 
16651 
  thrift_spec = (
16652 
    (0, TType.BOOL, 'success', None, None, ), # 0
16653 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16654 
  )
16655 
 
16656 
  def __init__(self, success=None, ex=None,):
16657 
    self.success = success
16658 
    self.ex = ex
16659 
 
16660 
  def read(self, iprot):
16661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16663 
      return
16664 
    iprot.readStructBegin()
16665 
    while True:
16666 
      (fname, ftype, fid) = iprot.readFieldBegin()
16667 
      if ftype == TType.STOP:
16668 
        break
16669 
      if fid == 0:
16670 
        if ftype == TType.BOOL:
16671 
          self.success = iprot.readBool();
16672 
        else:
16673 
          iprot.skip(ftype)
16674 
      elif fid == 1:
16675 
        if ftype == TType.STRUCT:
16676 
          self.ex = TransactionServiceException()
16677 
          self.ex.read(iprot)
16678 
        else:
16679 
          iprot.skip(ftype)
16680 
      else:
16681 
        iprot.skip(ftype)
16682 
      iprot.readFieldEnd()
16683 
    iprot.readStructEnd()
16684 
 
16685 
  def write(self, oprot):
16686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16688 
      return
2616 chandransh 16689 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 16690 
    if self.success is not None:
2591 chandransh 16691 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16692 
      oprot.writeBool(self.success)
16693 
      oprot.writeFieldEnd()
3431 rajveer 16694 
    if self.ex is not None:
2591 chandransh 16695 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16696 
      self.ex.write(oprot)
16697 
      oprot.writeFieldEnd()
16698 
    oprot.writeFieldStop()
16699 
    oprot.writeStructEnd()
16700 
 
3431 rajveer 16701 
  def validate(self):
16702 
    return
16703 
 
16704 
 
2591 chandransh 16705 
  def __repr__(self):
16706 
    L = ['%s=%r' % (key, value)
16707 
      for key, value in self.__dict__.iteritems()]
16708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16709 
 
16710 
  def __eq__(self, other):
16711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16712 
 
16713 
  def __ne__(self, other):
16714 
    return not (self == other)
16715 
 
16716 
class validateDoa_args:
16717 
  """
16718 
  Attributes:
16719 
   - orderId
16720 
   - isValid
16721 
  """
16722 
 
16723 
  thrift_spec = (
16724 
    None, # 0
16725 
    (1, TType.I64, 'orderId', None, None, ), # 1
16726 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
16727 
  )
16728 
 
16729 
  def __init__(self, orderId=None, isValid=None,):
16730 
    self.orderId = orderId
16731 
    self.isValid = isValid
16732 
 
16733 
  def read(self, iprot):
16734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16736 
      return
16737 
    iprot.readStructBegin()
16738 
    while True:
16739 
      (fname, ftype, fid) = iprot.readFieldBegin()
16740 
      if ftype == TType.STOP:
16741 
        break
16742 
      if fid == 1:
16743 
        if ftype == TType.I64:
16744 
          self.orderId = iprot.readI64();
16745 
        else:
16746 
          iprot.skip(ftype)
16747 
      elif fid == 2:
16748 
        if ftype == TType.BOOL:
16749 
          self.isValid = iprot.readBool();
16750 
        else:
16751 
          iprot.skip(ftype)
16752 
      else:
16753 
        iprot.skip(ftype)
16754 
      iprot.readFieldEnd()
16755 
    iprot.readStructEnd()
16756 
 
16757 
  def write(self, oprot):
16758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16760 
      return
16761 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 16762 
    if self.orderId is not None:
2591 chandransh 16763 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16764 
      oprot.writeI64(self.orderId)
16765 
      oprot.writeFieldEnd()
3431 rajveer 16766 
    if self.isValid is not None:
2591 chandransh 16767 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
16768 
      oprot.writeBool(self.isValid)
16769 
      oprot.writeFieldEnd()
16770 
    oprot.writeFieldStop()
16771 
    oprot.writeStructEnd()
16772 
 
3431 rajveer 16773 
  def validate(self):
16774 
    return
16775 
 
16776 
 
2591 chandransh 16777 
  def __repr__(self):
16778 
    L = ['%s=%r' % (key, value)
16779 
      for key, value in self.__dict__.iteritems()]
16780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16781 
 
16782 
  def __eq__(self, other):
16783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16784 
 
16785 
  def __ne__(self, other):
16786 
    return not (self == other)
16787 
 
16788 
class validateDoa_result:
16789 
  """
16790 
  Attributes:
16791 
   - success
16792 
   - ex
16793 
  """
16794 
 
16795 
  thrift_spec = (
16796 
    (0, TType.BOOL, 'success', None, None, ), # 0
16797 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16798 
  )
16799 
 
16800 
  def __init__(self, success=None, ex=None,):
16801 
    self.success = success
16802 
    self.ex = ex
16803 
 
16804 
  def read(self, iprot):
16805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16807 
      return
16808 
    iprot.readStructBegin()
16809 
    while True:
16810 
      (fname, ftype, fid) = iprot.readFieldBegin()
16811 
      if ftype == TType.STOP:
16812 
        break
16813 
      if fid == 0:
16814 
        if ftype == TType.BOOL:
16815 
          self.success = iprot.readBool();
16816 
        else:
16817 
          iprot.skip(ftype)
16818 
      elif fid == 1:
16819 
        if ftype == TType.STRUCT:
16820 
          self.ex = TransactionServiceException()
16821 
          self.ex.read(iprot)
16822 
        else:
16823 
          iprot.skip(ftype)
16824 
      else:
16825 
        iprot.skip(ftype)
16826 
      iprot.readFieldEnd()
16827 
    iprot.readStructEnd()
16828 
 
16829 
  def write(self, oprot):
16830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16832 
      return
16833 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 16834 
    if self.success is not None:
2591 chandransh 16835 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16836 
      oprot.writeBool(self.success)
16837 
      oprot.writeFieldEnd()
3431 rajveer 16838 
    if self.ex is not None:
2591 chandransh 16839 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16840 
      self.ex.write(oprot)
16841 
      oprot.writeFieldEnd()
16842 
    oprot.writeFieldStop()
16843 
    oprot.writeStructEnd()
16844 
 
3431 rajveer 16845 
  def validate(self):
16846 
    return
16847 
 
16848 
 
2591 chandransh 16849 
  def __repr__(self):
16850 
    L = ['%s=%r' % (key, value)
16851 
      for key, value in self.__dict__.iteritems()]
16852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16853 
 
16854 
  def __eq__(self, other):
16855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16856 
 
16857 
  def __ne__(self, other):
16858 
    return not (self == other)
16859 
 
4495 rajveer 16860 
class validateReturnProduct_args:
16861 
  """
16862 
  Attributes:
16863 
   - orderId
16864 
   - isUsable
16865 
  """
16866 
 
16867 
  thrift_spec = (
16868 
    None, # 0
16869 
    (1, TType.I64, 'orderId', None, None, ), # 1
16870 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
16871 
  )
16872 
 
16873 
  def __init__(self, orderId=None, isUsable=None,):
16874 
    self.orderId = orderId
16875 
    self.isUsable = isUsable
16876 
 
16877 
  def read(self, iprot):
16878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16880 
      return
16881 
    iprot.readStructBegin()
16882 
    while True:
16883 
      (fname, ftype, fid) = iprot.readFieldBegin()
16884 
      if ftype == TType.STOP:
16885 
        break
16886 
      if fid == 1:
16887 
        if ftype == TType.I64:
16888 
          self.orderId = iprot.readI64();
16889 
        else:
16890 
          iprot.skip(ftype)
16891 
      elif fid == 2:
16892 
        if ftype == TType.BOOL:
16893 
          self.isUsable = iprot.readBool();
16894 
        else:
16895 
          iprot.skip(ftype)
16896 
      else:
16897 
        iprot.skip(ftype)
16898 
      iprot.readFieldEnd()
16899 
    iprot.readStructEnd()
16900 
 
16901 
  def write(self, oprot):
16902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16904 
      return
16905 
    oprot.writeStructBegin('validateReturnProduct_args')
16906 
    if self.orderId is not None:
16907 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16908 
      oprot.writeI64(self.orderId)
16909 
      oprot.writeFieldEnd()
16910 
    if self.isUsable is not None:
16911 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
16912 
      oprot.writeBool(self.isUsable)
16913 
      oprot.writeFieldEnd()
16914 
    oprot.writeFieldStop()
16915 
    oprot.writeStructEnd()
16916 
 
16917 
  def validate(self):
16918 
    return
16919 
 
16920 
 
16921 
  def __repr__(self):
16922 
    L = ['%s=%r' % (key, value)
16923 
      for key, value in self.__dict__.iteritems()]
16924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16925 
 
16926 
  def __eq__(self, other):
16927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16928 
 
16929 
  def __ne__(self, other):
16930 
    return not (self == other)
16931 
 
16932 
class validateReturnProduct_result:
16933 
  """
16934 
  Attributes:
16935 
   - success
16936 
   - ex
16937 
  """
16938 
 
16939 
  thrift_spec = (
16940 
    (0, TType.BOOL, 'success', None, None, ), # 0
16941 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16942 
  )
16943 
 
16944 
  def __init__(self, success=None, ex=None,):
16945 
    self.success = success
16946 
    self.ex = ex
16947 
 
16948 
  def read(self, iprot):
16949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16951 
      return
16952 
    iprot.readStructBegin()
16953 
    while True:
16954 
      (fname, ftype, fid) = iprot.readFieldBegin()
16955 
      if ftype == TType.STOP:
16956 
        break
16957 
      if fid == 0:
16958 
        if ftype == TType.BOOL:
16959 
          self.success = iprot.readBool();
16960 
        else:
16961 
          iprot.skip(ftype)
16962 
      elif fid == 1:
16963 
        if ftype == TType.STRUCT:
16964 
          self.ex = TransactionServiceException()
16965 
          self.ex.read(iprot)
16966 
        else:
16967 
          iprot.skip(ftype)
16968 
      else:
16969 
        iprot.skip(ftype)
16970 
      iprot.readFieldEnd()
16971 
    iprot.readStructEnd()
16972 
 
16973 
  def write(self, oprot):
16974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16976 
      return
16977 
    oprot.writeStructBegin('validateReturnProduct_result')
16978 
    if self.success is not None:
16979 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16980 
      oprot.writeBool(self.success)
16981 
      oprot.writeFieldEnd()
16982 
    if self.ex is not None:
16983 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16984 
      self.ex.write(oprot)
16985 
      oprot.writeFieldEnd()
16986 
    oprot.writeFieldStop()
16987 
    oprot.writeStructEnd()
16988 
 
16989 
  def validate(self):
16990 
    return
16991 
 
16992 
 
16993 
  def __repr__(self):
16994 
    L = ['%s=%r' % (key, value)
16995 
      for key, value in self.__dict__.iteritems()]
16996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16997 
 
16998 
  def __eq__(self, other):
16999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17000 
 
17001 
  def __ne__(self, other):
17002 
    return not (self == other)
17003 
 
2616 chandransh 17004 
class reshipOrder_args:
17005 
  """
17006 
  Attributes:
17007 
   - orderId
17008 
  """
2591 chandransh 17009 
 
2616 chandransh 17010 
  thrift_spec = (
17011 
    None, # 0
17012 
    (1, TType.I64, 'orderId', None, None, ), # 1
17013 
  )
17014 
 
17015 
  def __init__(self, orderId=None,):
17016 
    self.orderId = orderId
17017 
 
17018 
  def read(self, iprot):
17019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17021 
      return
17022 
    iprot.readStructBegin()
17023 
    while True:
17024 
      (fname, ftype, fid) = iprot.readFieldBegin()
17025 
      if ftype == TType.STOP:
17026 
        break
17027 
      if fid == 1:
17028 
        if ftype == TType.I64:
17029 
          self.orderId = iprot.readI64();
17030 
        else:
17031 
          iprot.skip(ftype)
17032 
      else:
17033 
        iprot.skip(ftype)
17034 
      iprot.readFieldEnd()
17035 
    iprot.readStructEnd()
17036 
 
17037 
  def write(self, oprot):
17038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17040 
      return
17041 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 17042 
    if self.orderId is not None:
2616 chandransh 17043 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17044 
      oprot.writeI64(self.orderId)
17045 
      oprot.writeFieldEnd()
17046 
    oprot.writeFieldStop()
17047 
    oprot.writeStructEnd()
17048 
 
3431 rajveer 17049 
  def validate(self):
17050 
    return
17051 
 
17052 
 
2616 chandransh 17053 
  def __repr__(self):
17054 
    L = ['%s=%r' % (key, value)
17055 
      for key, value in self.__dict__.iteritems()]
17056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17057 
 
17058 
  def __eq__(self, other):
17059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17060 
 
17061 
  def __ne__(self, other):
17062 
    return not (self == other)
17063 
 
17064 
class reshipOrder_result:
17065 
  """
17066 
  Attributes:
17067 
   - success
17068 
   - ex
17069 
  """
17070 
 
17071 
  thrift_spec = (
17072 
    (0, TType.I64, 'success', None, None, ), # 0
17073 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17074 
  )
17075 
 
17076 
  def __init__(self, success=None, ex=None,):
17077 
    self.success = success
17078 
    self.ex = ex
17079 
 
17080 
  def read(self, iprot):
17081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17083 
      return
17084 
    iprot.readStructBegin()
17085 
    while True:
17086 
      (fname, ftype, fid) = iprot.readFieldBegin()
17087 
      if ftype == TType.STOP:
17088 
        break
17089 
      if fid == 0:
17090 
        if ftype == TType.I64:
17091 
          self.success = iprot.readI64();
17092 
        else:
17093 
          iprot.skip(ftype)
17094 
      elif fid == 1:
17095 
        if ftype == TType.STRUCT:
17096 
          self.ex = TransactionServiceException()
17097 
          self.ex.read(iprot)
17098 
        else:
17099 
          iprot.skip(ftype)
17100 
      else:
17101 
        iprot.skip(ftype)
17102 
      iprot.readFieldEnd()
17103 
    iprot.readStructEnd()
17104 
 
17105 
  def write(self, oprot):
17106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17108 
      return
17109 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 17110 
    if self.success is not None:
2616 chandransh 17111 
      oprot.writeFieldBegin('success', TType.I64, 0)
17112 
      oprot.writeI64(self.success)
17113 
      oprot.writeFieldEnd()
3431 rajveer 17114 
    if self.ex is not None:
2616 chandransh 17115 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17116 
      self.ex.write(oprot)
17117 
      oprot.writeFieldEnd()
17118 
    oprot.writeFieldStop()
17119 
    oprot.writeStructEnd()
17120 
 
3431 rajveer 17121 
  def validate(self):
17122 
    return
17123 
 
17124 
 
2616 chandransh 17125 
  def __repr__(self):
17126 
    L = ['%s=%r' % (key, value)
17127 
      for key, value in self.__dict__.iteritems()]
17128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17129 
 
17130 
  def __eq__(self, other):
17131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17132 
 
17133 
  def __ne__(self, other):
17134 
    return not (self == other)
17135 
 
17136 
class refundOrder_args:
17137 
  """
17138 
  Attributes:
17139 
   - orderId
3226 chandransh 17140 
   - refundedBy
17141 
   - reason
2616 chandransh 17142 
  """
17143 
 
17144 
  thrift_spec = (
17145 
    None, # 0
17146 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 17147 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
17148 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 17149 
  )
17150 
 
3226 chandransh 17151 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 17152 
    self.orderId = orderId
3226 chandransh 17153 
    self.refundedBy = refundedBy
17154 
    self.reason = reason
2616 chandransh 17155 
 
17156 
  def read(self, iprot):
17157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17159 
      return
17160 
    iprot.readStructBegin()
17161 
    while True:
17162 
      (fname, ftype, fid) = iprot.readFieldBegin()
17163 
      if ftype == TType.STOP:
17164 
        break
17165 
      if fid == 1:
17166 
        if ftype == TType.I64:
17167 
          self.orderId = iprot.readI64();
17168 
        else:
17169 
          iprot.skip(ftype)
3226 chandransh 17170 
      elif fid == 2:
17171 
        if ftype == TType.STRING:
17172 
          self.refundedBy = iprot.readString();
17173 
        else:
17174 
          iprot.skip(ftype)
17175 
      elif fid == 3:
17176 
        if ftype == TType.STRING:
17177 
          self.reason = iprot.readString();
17178 
        else:
17179 
          iprot.skip(ftype)
2616 chandransh 17180 
      else:
17181 
        iprot.skip(ftype)
17182 
      iprot.readFieldEnd()
17183 
    iprot.readStructEnd()
17184 
 
17185 
  def write(self, oprot):
17186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17188 
      return
17189 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 17190 
    if self.orderId is not None:
2616 chandransh 17191 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17192 
      oprot.writeI64(self.orderId)
17193 
      oprot.writeFieldEnd()
3431 rajveer 17194 
    if self.refundedBy is not None:
3226 chandransh 17195 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
17196 
      oprot.writeString(self.refundedBy)
17197 
      oprot.writeFieldEnd()
3431 rajveer 17198 
    if self.reason is not None:
3226 chandransh 17199 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
17200 
      oprot.writeString(self.reason)
17201 
      oprot.writeFieldEnd()
2616 chandransh 17202 
    oprot.writeFieldStop()
17203 
    oprot.writeStructEnd()
17204 
 
3431 rajveer 17205 
  def validate(self):
17206 
    return
17207 
 
17208 
 
2616 chandransh 17209 
  def __repr__(self):
17210 
    L = ['%s=%r' % (key, value)
17211 
      for key, value in self.__dict__.iteritems()]
17212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17213 
 
17214 
  def __eq__(self, other):
17215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17216 
 
17217 
  def __ne__(self, other):
17218 
    return not (self == other)
17219 
 
17220 
class refundOrder_result:
17221 
  """
17222 
  Attributes:
17223 
   - success
17224 
   - ex
17225 
  """
17226 
 
17227 
  thrift_spec = (
17228 
    (0, TType.BOOL, 'success', None, None, ), # 0
17229 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17230 
  )
17231 
 
17232 
  def __init__(self, success=None, ex=None,):
17233 
    self.success = success
17234 
    self.ex = ex
17235 
 
17236 
  def read(self, iprot):
17237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17239 
      return
17240 
    iprot.readStructBegin()
17241 
    while True:
17242 
      (fname, ftype, fid) = iprot.readFieldBegin()
17243 
      if ftype == TType.STOP:
17244 
        break
17245 
      if fid == 0:
17246 
        if ftype == TType.BOOL:
17247 
          self.success = iprot.readBool();
17248 
        else:
17249 
          iprot.skip(ftype)
17250 
      elif fid == 1:
17251 
        if ftype == TType.STRUCT:
17252 
          self.ex = TransactionServiceException()
17253 
          self.ex.read(iprot)
17254 
        else:
17255 
          iprot.skip(ftype)
17256 
      else:
17257 
        iprot.skip(ftype)
17258 
      iprot.readFieldEnd()
17259 
    iprot.readStructEnd()
17260 
 
17261 
  def write(self, oprot):
17262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17264 
      return
17265 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 17266 
    if self.success is not None:
2616 chandransh 17267 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17268 
      oprot.writeBool(self.success)
17269 
      oprot.writeFieldEnd()
3431 rajveer 17270 
    if self.ex is not None:
2616 chandransh 17271 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17272 
      self.ex.write(oprot)
17273 
      oprot.writeFieldEnd()
17274 
    oprot.writeFieldStop()
17275 
    oprot.writeStructEnd()
17276 
 
3431 rajveer 17277 
  def validate(self):
17278 
    return
17279 
 
17280 
 
2616 chandransh 17281 
  def __repr__(self):
17282 
    L = ['%s=%r' % (key, value)
17283 
      for key, value in self.__dict__.iteritems()]
17284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17285 
 
17286 
  def __eq__(self, other):
17287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17288 
 
17289 
  def __ne__(self, other):
17290 
    return not (self == other)
17291 
 
2690 chandransh 17292 
class getReturnOrders_args:
17293 
  """
17294 
  Attributes:
17295 
   - warehouseId
17296 
   - fromDate
17297 
   - toDate
17298 
  """
2616 chandransh 17299 
 
2690 chandransh 17300 
  thrift_spec = (
17301 
    None, # 0
17302 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
17303 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17304 
    (3, TType.I64, 'toDate', None, None, ), # 3
17305 
  )
17306 
 
17307 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
17308 
    self.warehouseId = warehouseId
17309 
    self.fromDate = fromDate
17310 
    self.toDate = toDate
17311 
 
17312 
  def read(self, iprot):
17313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17315 
      return
17316 
    iprot.readStructBegin()
17317 
    while True:
17318 
      (fname, ftype, fid) = iprot.readFieldBegin()
17319 
      if ftype == TType.STOP:
17320 
        break
17321 
      if fid == 1:
17322 
        if ftype == TType.I64:
17323 
          self.warehouseId = iprot.readI64();
17324 
        else:
17325 
          iprot.skip(ftype)
17326 
      elif fid == 2:
17327 
        if ftype == TType.I64:
17328 
          self.fromDate = iprot.readI64();
17329 
        else:
17330 
          iprot.skip(ftype)
17331 
      elif fid == 3:
17332 
        if ftype == TType.I64:
17333 
          self.toDate = iprot.readI64();
17334 
        else:
17335 
          iprot.skip(ftype)
17336 
      else:
17337 
        iprot.skip(ftype)
17338 
      iprot.readFieldEnd()
17339 
    iprot.readStructEnd()
17340 
 
17341 
  def write(self, oprot):
17342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17344 
      return
17345 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 17346 
    if self.warehouseId is not None:
2690 chandransh 17347 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
17348 
      oprot.writeI64(self.warehouseId)
17349 
      oprot.writeFieldEnd()
3431 rajveer 17350 
    if self.fromDate is not None:
2690 chandransh 17351 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17352 
      oprot.writeI64(self.fromDate)
17353 
      oprot.writeFieldEnd()
3431 rajveer 17354 
    if self.toDate is not None:
2690 chandransh 17355 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17356 
      oprot.writeI64(self.toDate)
17357 
      oprot.writeFieldEnd()
17358 
    oprot.writeFieldStop()
17359 
    oprot.writeStructEnd()
17360 
 
3431 rajveer 17361 
  def validate(self):
17362 
    return
17363 
 
17364 
 
2690 chandransh 17365 
  def __repr__(self):
17366 
    L = ['%s=%r' % (key, value)
17367 
      for key, value in self.__dict__.iteritems()]
17368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17369 
 
17370 
  def __eq__(self, other):
17371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17372 
 
17373 
  def __ne__(self, other):
17374 
    return not (self == other)
17375 
 
17376 
class getReturnOrders_result:
17377 
  """
17378 
  Attributes:
17379 
   - success
17380 
  """
17381 
 
17382 
  thrift_spec = (
17383 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
17384 
  )
17385 
 
17386 
  def __init__(self, success=None,):
17387 
    self.success = success
17388 
 
17389 
  def read(self, iprot):
17390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17392 
      return
17393 
    iprot.readStructBegin()
17394 
    while True:
17395 
      (fname, ftype, fid) = iprot.readFieldBegin()
17396 
      if ftype == TType.STOP:
17397 
        break
17398 
      if fid == 0:
17399 
        if ftype == TType.LIST:
17400 
          self.success = []
5713 rajveer 17401 
          (_etype399, _size396) = iprot.readListBegin()
17402 
          for _i400 in xrange(_size396):
17403 
            _elem401 = ReturnOrder()
17404 
            _elem401.read(iprot)
17405 
            self.success.append(_elem401)
2690 chandransh 17406 
          iprot.readListEnd()
17407 
        else:
17408 
          iprot.skip(ftype)
17409 
      else:
17410 
        iprot.skip(ftype)
17411 
      iprot.readFieldEnd()
17412 
    iprot.readStructEnd()
17413 
 
17414 
  def write(self, oprot):
17415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17417 
      return
17418 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 17419 
    if self.success is not None:
2690 chandransh 17420 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17421 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 17422 
      for iter402 in self.success:
17423 
        iter402.write(oprot)
2690 chandransh 17424 
      oprot.writeListEnd()
17425 
      oprot.writeFieldEnd()
17426 
    oprot.writeFieldStop()
17427 
    oprot.writeStructEnd()
17428 
 
3431 rajveer 17429 
  def validate(self):
17430 
    return
17431 
 
17432 
 
2690 chandransh 17433 
  def __repr__(self):
17434 
    L = ['%s=%r' % (key, value)
17435 
      for key, value in self.__dict__.iteritems()]
17436 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17437 
 
17438 
  def __eq__(self, other):
17439 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17440 
 
17441 
  def __ne__(self, other):
17442 
    return not (self == other)
17443 
 
5481 phani.kuma 17444 
class getAllReturnOrders_args:
17445 
  """
17446 
  Attributes:
17447 
   - onlyNotProcessed
17448 
   - fromDate
17449 
   - toDate
17450 
  """
17451 
 
17452 
  thrift_spec = (
17453 
    None, # 0
17454 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
17455 
    (2, TType.I64, 'fromDate', None, None, ), # 2
17456 
    (3, TType.I64, 'toDate', None, None, ), # 3
17457 
  )
17458 
 
17459 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
17460 
    self.onlyNotProcessed = onlyNotProcessed
17461 
    self.fromDate = fromDate
17462 
    self.toDate = toDate
17463 
 
17464 
  def read(self, iprot):
17465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17467 
      return
17468 
    iprot.readStructBegin()
17469 
    while True:
17470 
      (fname, ftype, fid) = iprot.readFieldBegin()
17471 
      if ftype == TType.STOP:
17472 
        break
17473 
      if fid == 1:
17474 
        if ftype == TType.BOOL:
17475 
          self.onlyNotProcessed = iprot.readBool();
17476 
        else:
17477 
          iprot.skip(ftype)
17478 
      elif fid == 2:
17479 
        if ftype == TType.I64:
17480 
          self.fromDate = iprot.readI64();
17481 
        else:
17482 
          iprot.skip(ftype)
17483 
      elif fid == 3:
17484 
        if ftype == TType.I64:
17485 
          self.toDate = iprot.readI64();
17486 
        else:
17487 
          iprot.skip(ftype)
17488 
      else:
17489 
        iprot.skip(ftype)
17490 
      iprot.readFieldEnd()
17491 
    iprot.readStructEnd()
17492 
 
17493 
  def write(self, oprot):
17494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17496 
      return
17497 
    oprot.writeStructBegin('getAllReturnOrders_args')
17498 
    if self.onlyNotProcessed is not None:
17499 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
17500 
      oprot.writeBool(self.onlyNotProcessed)
17501 
      oprot.writeFieldEnd()
17502 
    if self.fromDate is not None:
17503 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
17504 
      oprot.writeI64(self.fromDate)
17505 
      oprot.writeFieldEnd()
17506 
    if self.toDate is not None:
17507 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
17508 
      oprot.writeI64(self.toDate)
17509 
      oprot.writeFieldEnd()
17510 
    oprot.writeFieldStop()
17511 
    oprot.writeStructEnd()
17512 
 
17513 
  def validate(self):
17514 
    return
17515 
 
17516 
 
17517 
  def __repr__(self):
17518 
    L = ['%s=%r' % (key, value)
17519 
      for key, value in self.__dict__.iteritems()]
17520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17521 
 
17522 
  def __eq__(self, other):
17523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17524 
 
17525 
  def __ne__(self, other):
17526 
    return not (self == other)
17527 
 
17528 
class getAllReturnOrders_result:
17529 
  """
17530 
  Attributes:
17531 
   - success
17532 
  """
17533 
 
17534 
  thrift_spec = (
17535 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
17536 
  )
17537 
 
17538 
  def __init__(self, success=None,):
17539 
    self.success = success
17540 
 
17541 
  def read(self, iprot):
17542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17544 
      return
17545 
    iprot.readStructBegin()
17546 
    while True:
17547 
      (fname, ftype, fid) = iprot.readFieldBegin()
17548 
      if ftype == TType.STOP:
17549 
        break
17550 
      if fid == 0:
17551 
        if ftype == TType.LIST:
17552 
          self.success = []
5713 rajveer 17553 
          (_etype406, _size403) = iprot.readListBegin()
17554 
          for _i407 in xrange(_size403):
17555 
            _elem408 = ReturnOrder()
17556 
            _elem408.read(iprot)
17557 
            self.success.append(_elem408)
5481 phani.kuma 17558 
          iprot.readListEnd()
17559 
        else:
17560 
          iprot.skip(ftype)
17561 
      else:
17562 
        iprot.skip(ftype)
17563 
      iprot.readFieldEnd()
17564 
    iprot.readStructEnd()
17565 
 
17566 
  def write(self, oprot):
17567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17569 
      return
17570 
    oprot.writeStructBegin('getAllReturnOrders_result')
17571 
    if self.success is not None:
17572 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17573 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 17574 
      for iter409 in self.success:
17575 
        iter409.write(oprot)
5481 phani.kuma 17576 
      oprot.writeListEnd()
17577 
      oprot.writeFieldEnd()
17578 
    oprot.writeFieldStop()
17579 
    oprot.writeStructEnd()
17580 
 
17581 
  def validate(self):
17582 
    return
17583 
 
17584 
 
17585 
  def __repr__(self):
17586 
    L = ['%s=%r' % (key, value)
17587 
      for key, value in self.__dict__.iteritems()]
17588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17589 
 
17590 
  def __eq__(self, other):
17591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17592 
 
17593 
  def __ne__(self, other):
17594 
    return not (self == other)
17595 
 
2700 chandransh 17596 
class getReturnOrder_args:
17597 
  """
17598 
  Attributes:
17599 
   - id
17600 
  """
17601 
 
17602 
  thrift_spec = (
17603 
    None, # 0
17604 
    (1, TType.I64, 'id', None, None, ), # 1
17605 
  )
17606 
 
17607 
  def __init__(self, id=None,):
17608 
    self.id = id
17609 
 
17610 
  def read(self, iprot):
17611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17613 
      return
17614 
    iprot.readStructBegin()
17615 
    while True:
17616 
      (fname, ftype, fid) = iprot.readFieldBegin()
17617 
      if ftype == TType.STOP:
17618 
        break
17619 
      if fid == 1:
17620 
        if ftype == TType.I64:
17621 
          self.id = iprot.readI64();
17622 
        else:
17623 
          iprot.skip(ftype)
17624 
      else:
17625 
        iprot.skip(ftype)
17626 
      iprot.readFieldEnd()
17627 
    iprot.readStructEnd()
17628 
 
17629 
  def write(self, oprot):
17630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17632 
      return
17633 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 17634 
    if self.id is not None:
2700 chandransh 17635 
      oprot.writeFieldBegin('id', TType.I64, 1)
17636 
      oprot.writeI64(self.id)
17637 
      oprot.writeFieldEnd()
17638 
    oprot.writeFieldStop()
17639 
    oprot.writeStructEnd()
17640 
 
3431 rajveer 17641 
  def validate(self):
17642 
    return
17643 
 
17644 
 
2700 chandransh 17645 
  def __repr__(self):
17646 
    L = ['%s=%r' % (key, value)
17647 
      for key, value in self.__dict__.iteritems()]
17648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17649 
 
17650 
  def __eq__(self, other):
17651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17652 
 
17653 
  def __ne__(self, other):
17654 
    return not (self == other)
17655 
 
17656 
class getReturnOrder_result:
17657 
  """
17658 
  Attributes:
17659 
   - success
17660 
   - ex
17661 
  """
17662 
 
17663 
  thrift_spec = (
17664 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
17665 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17666 
  )
17667 
 
17668 
  def __init__(self, success=None, ex=None,):
17669 
    self.success = success
17670 
    self.ex = ex
17671 
 
17672 
  def read(self, iprot):
17673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17675 
      return
17676 
    iprot.readStructBegin()
17677 
    while True:
17678 
      (fname, ftype, fid) = iprot.readFieldBegin()
17679 
      if ftype == TType.STOP:
17680 
        break
17681 
      if fid == 0:
17682 
        if ftype == TType.STRUCT:
17683 
          self.success = ReturnOrder()
17684 
          self.success.read(iprot)
17685 
        else:
17686 
          iprot.skip(ftype)
17687 
      elif fid == 1:
17688 
        if ftype == TType.STRUCT:
17689 
          self.ex = TransactionServiceException()
17690 
          self.ex.read(iprot)
17691 
        else:
17692 
          iprot.skip(ftype)
17693 
      else:
17694 
        iprot.skip(ftype)
17695 
      iprot.readFieldEnd()
17696 
    iprot.readStructEnd()
17697 
 
17698 
  def write(self, oprot):
17699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17701 
      return
17702 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 17703 
    if self.success is not None:
2700 chandransh 17704 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17705 
      self.success.write(oprot)
17706 
      oprot.writeFieldEnd()
3431 rajveer 17707 
    if self.ex is not None:
2700 chandransh 17708 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17709 
      self.ex.write(oprot)
17710 
      oprot.writeFieldEnd()
17711 
    oprot.writeFieldStop()
17712 
    oprot.writeStructEnd()
17713 
 
3431 rajveer 17714 
  def validate(self):
17715 
    return
17716 
 
17717 
 
2700 chandransh 17718 
  def __repr__(self):
17719 
    L = ['%s=%r' % (key, value)
17720 
      for key, value in self.__dict__.iteritems()]
17721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17722 
 
17723 
  def __eq__(self, other):
17724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17725 
 
17726 
  def __ne__(self, other):
17727 
    return not (self == other)
17728 
 
2690 chandransh 17729 
class processReturn_args:
17730 
  """
17731 
  Attributes:
17732 
   - returnOrderId
17733 
  """
17734 
 
17735 
  thrift_spec = (
17736 
    None, # 0
17737 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
17738 
  )
17739 
 
17740 
  def __init__(self, returnOrderId=None,):
17741 
    self.returnOrderId = returnOrderId
17742 
 
17743 
  def read(self, iprot):
17744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17746 
      return
17747 
    iprot.readStructBegin()
17748 
    while True:
17749 
      (fname, ftype, fid) = iprot.readFieldBegin()
17750 
      if ftype == TType.STOP:
17751 
        break
17752 
      if fid == 1:
17753 
        if ftype == TType.I64:
17754 
          self.returnOrderId = iprot.readI64();
17755 
        else:
17756 
          iprot.skip(ftype)
17757 
      else:
17758 
        iprot.skip(ftype)
17759 
      iprot.readFieldEnd()
17760 
    iprot.readStructEnd()
17761 
 
17762 
  def write(self, oprot):
17763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17765 
      return
17766 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 17767 
    if self.returnOrderId is not None:
2690 chandransh 17768 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
17769 
      oprot.writeI64(self.returnOrderId)
17770 
      oprot.writeFieldEnd()
17771 
    oprot.writeFieldStop()
17772 
    oprot.writeStructEnd()
17773 
 
3431 rajveer 17774 
  def validate(self):
17775 
    return
17776 
 
17777 
 
2690 chandransh 17778 
  def __repr__(self):
17779 
    L = ['%s=%r' % (key, value)
17780 
      for key, value in self.__dict__.iteritems()]
17781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17782 
 
17783 
  def __eq__(self, other):
17784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17785 
 
17786 
  def __ne__(self, other):
17787 
    return not (self == other)
17788 
 
17789 
class processReturn_result:
17790 
  """
17791 
  Attributes:
17792 
   - ex
17793 
  """
17794 
 
17795 
  thrift_spec = (
17796 
    None, # 0
17797 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17798 
  )
17799 
 
17800 
  def __init__(self, ex=None,):
17801 
    self.ex = ex
17802 
 
17803 
  def read(self, iprot):
17804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17806 
      return
17807 
    iprot.readStructBegin()
17808 
    while True:
17809 
      (fname, ftype, fid) = iprot.readFieldBegin()
17810 
      if ftype == TType.STOP:
17811 
        break
17812 
      if fid == 1:
17813 
        if ftype == TType.STRUCT:
17814 
          self.ex = TransactionServiceException()
17815 
          self.ex.read(iprot)
17816 
        else:
17817 
          iprot.skip(ftype)
17818 
      else:
17819 
        iprot.skip(ftype)
17820 
      iprot.readFieldEnd()
17821 
    iprot.readStructEnd()
17822 
 
17823 
  def write(self, oprot):
17824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17826 
      return
17827 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 17828 
    if self.ex is not None:
2690 chandransh 17829 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17830 
      self.ex.write(oprot)
17831 
      oprot.writeFieldEnd()
17832 
    oprot.writeFieldStop()
17833 
    oprot.writeStructEnd()
17834 
 
3431 rajveer 17835 
  def validate(self):
17836 
    return
17837 
 
17838 
 
2690 chandransh 17839 
  def __repr__(self):
17840 
    L = ['%s=%r' % (key, value)
17841 
      for key, value in self.__dict__.iteritems()]
17842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17843 
 
17844 
  def __eq__(self, other):
17845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17846 
 
17847 
  def __ne__(self, other):
17848 
    return not (self == other)
17849 
 
3451 chandransh 17850 
class updateWeight_args:
17851 
  """
17852 
  Attributes:
17853 
   - orderId
17854 
   - weight
17855 
  """
17856 
 
17857 
  thrift_spec = (
17858 
    None, # 0
17859 
    (1, TType.I64, 'orderId', None, None, ), # 1
17860 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
17861 
  )
17862 
 
17863 
  def __init__(self, orderId=None, weight=None,):
17864 
    self.orderId = orderId
17865 
    self.weight = weight
17866 
 
17867 
  def read(self, iprot):
17868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17870 
      return
17871 
    iprot.readStructBegin()
17872 
    while True:
17873 
      (fname, ftype, fid) = iprot.readFieldBegin()
17874 
      if ftype == TType.STOP:
17875 
        break
17876 
      if fid == 1:
17877 
        if ftype == TType.I64:
17878 
          self.orderId = iprot.readI64();
17879 
        else:
17880 
          iprot.skip(ftype)
17881 
      elif fid == 2:
17882 
        if ftype == TType.DOUBLE:
17883 
          self.weight = iprot.readDouble();
17884 
        else:
17885 
          iprot.skip(ftype)
17886 
      else:
17887 
        iprot.skip(ftype)
17888 
      iprot.readFieldEnd()
17889 
    iprot.readStructEnd()
17890 
 
17891 
  def write(self, oprot):
17892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17894 
      return
17895 
    oprot.writeStructBegin('updateWeight_args')
17896 
    if self.orderId is not None:
17897 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17898 
      oprot.writeI64(self.orderId)
17899 
      oprot.writeFieldEnd()
17900 
    if self.weight is not None:
17901 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
17902 
      oprot.writeDouble(self.weight)
17903 
      oprot.writeFieldEnd()
17904 
    oprot.writeFieldStop()
17905 
    oprot.writeStructEnd()
17906 
 
17907 
  def validate(self):
17908 
    return
17909 
 
17910 
 
17911 
  def __repr__(self):
17912 
    L = ['%s=%r' % (key, value)
17913 
      for key, value in self.__dict__.iteritems()]
17914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17915 
 
17916 
  def __eq__(self, other):
17917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17918 
 
17919 
  def __ne__(self, other):
17920 
    return not (self == other)
17921 
 
17922 
class updateWeight_result:
17923 
  """
17924 
  Attributes:
17925 
   - success
17926 
   - ex
17927 
  """
17928 
 
17929 
  thrift_spec = (
17930 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
17931 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17932 
  )
17933 
 
17934 
  def __init__(self, success=None, ex=None,):
17935 
    self.success = success
17936 
    self.ex = ex
17937 
 
17938 
  def read(self, iprot):
17939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17941 
      return
17942 
    iprot.readStructBegin()
17943 
    while True:
17944 
      (fname, ftype, fid) = iprot.readFieldBegin()
17945 
      if ftype == TType.STOP:
17946 
        break
17947 
      if fid == 0:
17948 
        if ftype == TType.STRUCT:
17949 
          self.success = Order()
17950 
          self.success.read(iprot)
17951 
        else:
17952 
          iprot.skip(ftype)
17953 
      elif fid == 1:
17954 
        if ftype == TType.STRUCT:
17955 
          self.ex = TransactionServiceException()
17956 
          self.ex.read(iprot)
17957 
        else:
17958 
          iprot.skip(ftype)
17959 
      else:
17960 
        iprot.skip(ftype)
17961 
      iprot.readFieldEnd()
17962 
    iprot.readStructEnd()
17963 
 
17964 
  def write(self, oprot):
17965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17967 
      return
17968 
    oprot.writeStructBegin('updateWeight_result')
17969 
    if self.success is not None:
17970 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17971 
      self.success.write(oprot)
17972 
      oprot.writeFieldEnd()
17973 
    if self.ex is not None:
17974 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17975 
      self.ex.write(oprot)
17976 
      oprot.writeFieldEnd()
17977 
    oprot.writeFieldStop()
17978 
    oprot.writeStructEnd()
17979 
 
17980 
  def validate(self):
17981 
    return
17982 
 
17983 
 
17984 
  def __repr__(self):
17985 
    L = ['%s=%r' % (key, value)
17986 
      for key, value in self.__dict__.iteritems()]
17987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17988 
 
17989 
  def __eq__(self, other):
17990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17991 
 
17992 
  def __ne__(self, other):
17993 
    return not (self == other)
3469 chandransh 17994 
 
17995 
class changeItem_args:
17996 
  """
17997 
  Attributes:
17998 
   - orderId
17999 
   - itemId
18000 
  """
18001 
 
18002 
  thrift_spec = (
18003 
    None, # 0
18004 
    (1, TType.I64, 'orderId', None, None, ), # 1
18005 
    (2, TType.I64, 'itemId', None, None, ), # 2
18006 
  )
18007 
 
18008 
  def __init__(self, orderId=None, itemId=None,):
18009 
    self.orderId = orderId
18010 
    self.itemId = itemId
18011 
 
18012 
  def read(self, iprot):
18013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18015 
      return
18016 
    iprot.readStructBegin()
18017 
    while True:
18018 
      (fname, ftype, fid) = iprot.readFieldBegin()
18019 
      if ftype == TType.STOP:
18020 
        break
18021 
      if fid == 1:
18022 
        if ftype == TType.I64:
18023 
          self.orderId = iprot.readI64();
18024 
        else:
18025 
          iprot.skip(ftype)
18026 
      elif fid == 2:
18027 
        if ftype == TType.I64:
18028 
          self.itemId = iprot.readI64();
18029 
        else:
18030 
          iprot.skip(ftype)
18031 
      else:
18032 
        iprot.skip(ftype)
18033 
      iprot.readFieldEnd()
18034 
    iprot.readStructEnd()
18035 
 
18036 
  def write(self, oprot):
18037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18039 
      return
18040 
    oprot.writeStructBegin('changeItem_args')
18041 
    if self.orderId is not None:
18042 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18043 
      oprot.writeI64(self.orderId)
18044 
      oprot.writeFieldEnd()
18045 
    if self.itemId is not None:
18046 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18047 
      oprot.writeI64(self.itemId)
18048 
      oprot.writeFieldEnd()
18049 
    oprot.writeFieldStop()
18050 
    oprot.writeStructEnd()
18051 
 
18052 
  def validate(self):
18053 
    return
18054 
 
18055 
 
18056 
  def __repr__(self):
18057 
    L = ['%s=%r' % (key, value)
18058 
      for key, value in self.__dict__.iteritems()]
18059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18060 
 
18061 
  def __eq__(self, other):
18062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18063 
 
18064 
  def __ne__(self, other):
18065 
    return not (self == other)
18066 
 
18067 
class changeItem_result:
18068 
  """
18069 
  Attributes:
18070 
   - success
18071 
   - ex
18072 
  """
18073 
 
18074 
  thrift_spec = (
18075 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18076 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18077 
  )
18078 
 
18079 
  def __init__(self, success=None, ex=None,):
18080 
    self.success = success
18081 
    self.ex = ex
18082 
 
18083 
  def read(self, iprot):
18084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18086 
      return
18087 
    iprot.readStructBegin()
18088 
    while True:
18089 
      (fname, ftype, fid) = iprot.readFieldBegin()
18090 
      if ftype == TType.STOP:
18091 
        break
18092 
      if fid == 0:
18093 
        if ftype == TType.STRUCT:
18094 
          self.success = Order()
18095 
          self.success.read(iprot)
18096 
        else:
18097 
          iprot.skip(ftype)
18098 
      elif fid == 1:
18099 
        if ftype == TType.STRUCT:
18100 
          self.ex = TransactionServiceException()
18101 
          self.ex.read(iprot)
18102 
        else:
18103 
          iprot.skip(ftype)
18104 
      else:
18105 
        iprot.skip(ftype)
18106 
      iprot.readFieldEnd()
18107 
    iprot.readStructEnd()
18108 
 
18109 
  def write(self, oprot):
18110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18112 
      return
18113 
    oprot.writeStructBegin('changeItem_result')
18114 
    if self.success is not None:
18115 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18116 
      self.success.write(oprot)
18117 
      oprot.writeFieldEnd()
18118 
    if self.ex is not None:
18119 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18120 
      self.ex.write(oprot)
18121 
      oprot.writeFieldEnd()
18122 
    oprot.writeFieldStop()
18123 
    oprot.writeStructEnd()
18124 
 
18125 
  def validate(self):
18126 
    return
18127 
 
18128 
 
18129 
  def __repr__(self):
18130 
    L = ['%s=%r' % (key, value)
18131 
      for key, value in self.__dict__.iteritems()]
18132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18133 
 
18134 
  def __eq__(self, other):
18135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18136 
 
18137 
  def __ne__(self, other):
18138 
    return not (self == other)
18139 
 
18140 
class shiftToWarehouse_args:
18141 
  """
18142 
  Attributes:
18143 
   - orderId
18144 
   - warehouseId
18145 
  """
18146 
 
18147 
  thrift_spec = (
18148 
    None, # 0
18149 
    (1, TType.I64, 'orderId', None, None, ), # 1
18150 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
18151 
  )
18152 
 
18153 
  def __init__(self, orderId=None, warehouseId=None,):
18154 
    self.orderId = orderId
18155 
    self.warehouseId = warehouseId
18156 
 
18157 
  def read(self, iprot):
18158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18160 
      return
18161 
    iprot.readStructBegin()
18162 
    while True:
18163 
      (fname, ftype, fid) = iprot.readFieldBegin()
18164 
      if ftype == TType.STOP:
18165 
        break
18166 
      if fid == 1:
18167 
        if ftype == TType.I64:
18168 
          self.orderId = iprot.readI64();
18169 
        else:
18170 
          iprot.skip(ftype)
18171 
      elif fid == 2:
18172 
        if ftype == TType.I64:
18173 
          self.warehouseId = iprot.readI64();
18174 
        else:
18175 
          iprot.skip(ftype)
18176 
      else:
18177 
        iprot.skip(ftype)
18178 
      iprot.readFieldEnd()
18179 
    iprot.readStructEnd()
18180 
 
18181 
  def write(self, oprot):
18182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18184 
      return
18185 
    oprot.writeStructBegin('shiftToWarehouse_args')
18186 
    if self.orderId is not None:
18187 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18188 
      oprot.writeI64(self.orderId)
18189 
      oprot.writeFieldEnd()
18190 
    if self.warehouseId is not None:
18191 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
18192 
      oprot.writeI64(self.warehouseId)
18193 
      oprot.writeFieldEnd()
18194 
    oprot.writeFieldStop()
18195 
    oprot.writeStructEnd()
18196 
 
18197 
  def validate(self):
18198 
    return
18199 
 
18200 
 
18201 
  def __repr__(self):
18202 
    L = ['%s=%r' % (key, value)
18203 
      for key, value in self.__dict__.iteritems()]
18204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18205 
 
18206 
  def __eq__(self, other):
18207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18208 
 
18209 
  def __ne__(self, other):
18210 
    return not (self == other)
18211 
 
18212 
class shiftToWarehouse_result:
18213 
  """
18214 
  Attributes:
18215 
   - success
18216 
   - ex
18217 
  """
18218 
 
18219 
  thrift_spec = (
18220 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18221 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18222 
  )
18223 
 
18224 
  def __init__(self, success=None, ex=None,):
18225 
    self.success = success
18226 
    self.ex = ex
18227 
 
18228 
  def read(self, iprot):
18229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18231 
      return
18232 
    iprot.readStructBegin()
18233 
    while True:
18234 
      (fname, ftype, fid) = iprot.readFieldBegin()
18235 
      if ftype == TType.STOP:
18236 
        break
18237 
      if fid == 0:
18238 
        if ftype == TType.STRUCT:
18239 
          self.success = Order()
18240 
          self.success.read(iprot)
18241 
        else:
18242 
          iprot.skip(ftype)
18243 
      elif fid == 1:
18244 
        if ftype == TType.STRUCT:
18245 
          self.ex = TransactionServiceException()
18246 
          self.ex.read(iprot)
18247 
        else:
18248 
          iprot.skip(ftype)
18249 
      else:
18250 
        iprot.skip(ftype)
18251 
      iprot.readFieldEnd()
18252 
    iprot.readStructEnd()
18253 
 
18254 
  def write(self, oprot):
18255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18257 
      return
18258 
    oprot.writeStructBegin('shiftToWarehouse_result')
18259 
    if self.success is not None:
18260 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18261 
      self.success.write(oprot)
18262 
      oprot.writeFieldEnd()
18263 
    if self.ex is not None:
18264 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18265 
      self.ex.write(oprot)
18266 
      oprot.writeFieldEnd()
18267 
    oprot.writeFieldStop()
18268 
    oprot.writeStructEnd()
18269 
 
18270 
  def validate(self):
18271 
    return
18272 
 
18273 
 
18274 
  def __repr__(self):
18275 
    L = ['%s=%r' % (key, value)
18276 
      for key, value in self.__dict__.iteritems()]
18277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18278 
 
18279 
  def __eq__(self, other):
18280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18281 
 
18282 
  def __ne__(self, other):
18283 
    return not (self == other)
3553 chandransh 18284 
 
18285 
class addDelayReason_args:
18286 
  """
18287 
  Attributes:
18288 
   - orderId
18289 
   - delayReason
3986 chandransh 18290 
   - furtherDelay
4647 rajveer 18291 
   - delayReasonText
3553 chandransh 18292 
  """
18293 
 
18294 
  thrift_spec = (
18295 
    None, # 0
18296 
    (1, TType.I64, 'orderId', None, None, ), # 1
18297 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 18298 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 18299 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 18300 
  )
18301 
 
4647 rajveer 18302 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 18303 
    self.orderId = orderId
18304 
    self.delayReason = delayReason
3986 chandransh 18305 
    self.furtherDelay = furtherDelay
4647 rajveer 18306 
    self.delayReasonText = delayReasonText
3553 chandransh 18307 
 
18308 
  def read(self, iprot):
18309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18311 
      return
18312 
    iprot.readStructBegin()
18313 
    while True:
18314 
      (fname, ftype, fid) = iprot.readFieldBegin()
18315 
      if ftype == TType.STOP:
18316 
        break
18317 
      if fid == 1:
18318 
        if ftype == TType.I64:
18319 
          self.orderId = iprot.readI64();
18320 
        else:
18321 
          iprot.skip(ftype)
18322 
      elif fid == 2:
18323 
        if ftype == TType.I32:
18324 
          self.delayReason = iprot.readI32();
18325 
        else:
18326 
          iprot.skip(ftype)
3986 chandransh 18327 
      elif fid == 3:
18328 
        if ftype == TType.I64:
18329 
          self.furtherDelay = iprot.readI64();
18330 
        else:
18331 
          iprot.skip(ftype)
4647 rajveer 18332 
      elif fid == 4:
18333 
        if ftype == TType.STRING:
18334 
          self.delayReasonText = iprot.readString();
18335 
        else:
18336 
          iprot.skip(ftype)
3553 chandransh 18337 
      else:
18338 
        iprot.skip(ftype)
18339 
      iprot.readFieldEnd()
18340 
    iprot.readStructEnd()
18341 
 
18342 
  def write(self, oprot):
18343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18345 
      return
18346 
    oprot.writeStructBegin('addDelayReason_args')
18347 
    if self.orderId is not None:
18348 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18349 
      oprot.writeI64(self.orderId)
18350 
      oprot.writeFieldEnd()
18351 
    if self.delayReason is not None:
18352 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
18353 
      oprot.writeI32(self.delayReason)
18354 
      oprot.writeFieldEnd()
3986 chandransh 18355 
    if self.furtherDelay is not None:
18356 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
18357 
      oprot.writeI64(self.furtherDelay)
18358 
      oprot.writeFieldEnd()
4647 rajveer 18359 
    if self.delayReasonText is not None:
18360 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
18361 
      oprot.writeString(self.delayReasonText)
18362 
      oprot.writeFieldEnd()
3553 chandransh 18363 
    oprot.writeFieldStop()
18364 
    oprot.writeStructEnd()
18365 
 
18366 
  def validate(self):
18367 
    return
18368 
 
18369 
 
18370 
  def __repr__(self):
18371 
    L = ['%s=%r' % (key, value)
18372 
      for key, value in self.__dict__.iteritems()]
18373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18374 
 
18375 
  def __eq__(self, other):
18376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18377 
 
18378 
  def __ne__(self, other):
18379 
    return not (self == other)
18380 
 
18381 
class addDelayReason_result:
18382 
  """
18383 
  Attributes:
18384 
   - success
18385 
   - ex
18386 
  """
18387 
 
18388 
  thrift_spec = (
18389 
    (0, TType.BOOL, 'success', None, None, ), # 0
18390 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18391 
  )
18392 
 
18393 
  def __init__(self, success=None, ex=None,):
18394 
    self.success = success
18395 
    self.ex = ex
18396 
 
18397 
  def read(self, iprot):
18398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18400 
      return
18401 
    iprot.readStructBegin()
18402 
    while True:
18403 
      (fname, ftype, fid) = iprot.readFieldBegin()
18404 
      if ftype == TType.STOP:
18405 
        break
18406 
      if fid == 0:
18407 
        if ftype == TType.BOOL:
18408 
          self.success = iprot.readBool();
18409 
        else:
18410 
          iprot.skip(ftype)
18411 
      elif fid == 1:
18412 
        if ftype == TType.STRUCT:
18413 
          self.ex = TransactionServiceException()
18414 
          self.ex.read(iprot)
18415 
        else:
18416 
          iprot.skip(ftype)
18417 
      else:
18418 
        iprot.skip(ftype)
18419 
      iprot.readFieldEnd()
18420 
    iprot.readStructEnd()
18421 
 
18422 
  def write(self, oprot):
18423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18425 
      return
18426 
    oprot.writeStructBegin('addDelayReason_result')
18427 
    if self.success is not None:
18428 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18429 
      oprot.writeBool(self.success)
18430 
      oprot.writeFieldEnd()
18431 
    if self.ex is not None:
18432 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18433 
      self.ex.write(oprot)
18434 
      oprot.writeFieldEnd()
18435 
    oprot.writeFieldStop()
18436 
    oprot.writeStructEnd()
18437 
 
18438 
  def validate(self):
18439 
    return
18440 
 
18441 
 
18442 
  def __repr__(self):
18443 
    L = ['%s=%r' % (key, value)
18444 
      for key, value in self.__dict__.iteritems()]
18445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18446 
 
18447 
  def __eq__(self, other):
18448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18449 
 
18450 
  def __ne__(self, other):
18451 
    return not (self == other)
3956 chandransh 18452 
 
18453 
class reconcileCodCollection_args:
18454 
  """
18455 
  Attributes:
18456 
   - collectedAmountMap
18457 
   - xferBy
18458 
   - xferTxnId
18459 
   - xferDate
18460 
  """
18461 
 
18462 
  thrift_spec = (
18463 
    None, # 0
18464 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
18465 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
18466 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
18467 
    (4, TType.I64, 'xferDate', None, None, ), # 4
18468 
  )
18469 
 
18470 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
18471 
    self.collectedAmountMap = collectedAmountMap
18472 
    self.xferBy = xferBy
18473 
    self.xferTxnId = xferTxnId
18474 
    self.xferDate = xferDate
18475 
 
18476 
  def read(self, iprot):
18477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18479 
      return
18480 
    iprot.readStructBegin()
18481 
    while True:
18482 
      (fname, ftype, fid) = iprot.readFieldBegin()
18483 
      if ftype == TType.STOP:
18484 
        break
18485 
      if fid == 1:
18486 
        if ftype == TType.MAP:
18487 
          self.collectedAmountMap = {}
5713 rajveer 18488 
          (_ktype411, _vtype412, _size410 ) = iprot.readMapBegin()
18489 
          for _i414 in xrange(_size410):
18490 
            _key415 = iprot.readString();
18491 
            _val416 = iprot.readDouble();
18492 
            self.collectedAmountMap[_key415] = _val416
3956 chandransh 18493 
          iprot.readMapEnd()
18494 
        else:
18495 
          iprot.skip(ftype)
18496 
      elif fid == 2:
18497 
        if ftype == TType.STRING:
18498 
          self.xferBy = iprot.readString();
18499 
        else:
18500 
          iprot.skip(ftype)
18501 
      elif fid == 3:
18502 
        if ftype == TType.STRING:
18503 
          self.xferTxnId = iprot.readString();
18504 
        else:
18505 
          iprot.skip(ftype)
18506 
      elif fid == 4:
18507 
        if ftype == TType.I64:
18508 
          self.xferDate = iprot.readI64();
18509 
        else:
18510 
          iprot.skip(ftype)
18511 
      else:
18512 
        iprot.skip(ftype)
18513 
      iprot.readFieldEnd()
18514 
    iprot.readStructEnd()
18515 
 
18516 
  def write(self, oprot):
18517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18519 
      return
18520 
    oprot.writeStructBegin('reconcileCodCollection_args')
18521 
    if self.collectedAmountMap is not None:
18522 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
18523 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
5713 rajveer 18524 
      for kiter417,viter418 in self.collectedAmountMap.items():
18525 
        oprot.writeString(kiter417)
18526 
        oprot.writeDouble(viter418)
3956 chandransh 18527 
      oprot.writeMapEnd()
18528 
      oprot.writeFieldEnd()
18529 
    if self.xferBy is not None:
18530 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
18531 
      oprot.writeString(self.xferBy)
18532 
      oprot.writeFieldEnd()
18533 
    if self.xferTxnId is not None:
18534 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
18535 
      oprot.writeString(self.xferTxnId)
18536 
      oprot.writeFieldEnd()
18537 
    if self.xferDate is not None:
18538 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
18539 
      oprot.writeI64(self.xferDate)
18540 
      oprot.writeFieldEnd()
18541 
    oprot.writeFieldStop()
18542 
    oprot.writeStructEnd()
18543 
 
18544 
  def validate(self):
18545 
    return
18546 
 
18547 
 
18548 
  def __repr__(self):
18549 
    L = ['%s=%r' % (key, value)
18550 
      for key, value in self.__dict__.iteritems()]
18551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18552 
 
18553 
  def __eq__(self, other):
18554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18555 
 
18556 
  def __ne__(self, other):
18557 
    return not (self == other)
18558 
 
18559 
class reconcileCodCollection_result:
18560 
  """
18561 
  Attributes:
18562 
   - success
18563 
   - ex
18564 
  """
18565 
 
18566 
  thrift_spec = (
18567 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
18568 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18569 
  )
18570 
 
18571 
  def __init__(self, success=None, ex=None,):
18572 
    self.success = success
18573 
    self.ex = ex
18574 
 
18575 
  def read(self, iprot):
18576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18578 
      return
18579 
    iprot.readStructBegin()
18580 
    while True:
18581 
      (fname, ftype, fid) = iprot.readFieldBegin()
18582 
      if ftype == TType.STOP:
18583 
        break
18584 
      if fid == 0:
18585 
        if ftype == TType.MAP:
18586 
          self.success = {}
5713 rajveer 18587 
          (_ktype420, _vtype421, _size419 ) = iprot.readMapBegin()
18588 
          for _i423 in xrange(_size419):
18589 
            _key424 = iprot.readString();
18590 
            _val425 = iprot.readString();
18591 
            self.success[_key424] = _val425
3956 chandransh 18592 
          iprot.readMapEnd()
18593 
        else:
18594 
          iprot.skip(ftype)
18595 
      elif fid == 1:
18596 
        if ftype == TType.STRUCT:
18597 
          self.ex = TransactionServiceException()
18598 
          self.ex.read(iprot)
18599 
        else:
18600 
          iprot.skip(ftype)
18601 
      else:
18602 
        iprot.skip(ftype)
18603 
      iprot.readFieldEnd()
18604 
    iprot.readStructEnd()
18605 
 
18606 
  def write(self, oprot):
18607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18609 
      return
18610 
    oprot.writeStructBegin('reconcileCodCollection_result')
18611 
    if self.success is not None:
18612 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18613 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
5713 rajveer 18614 
      for kiter426,viter427 in self.success.items():
18615 
        oprot.writeString(kiter426)
18616 
        oprot.writeString(viter427)
3956 chandransh 18617 
      oprot.writeMapEnd()
18618 
      oprot.writeFieldEnd()
18619 
    if self.ex is not None:
18620 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18621 
      self.ex.write(oprot)
18622 
      oprot.writeFieldEnd()
18623 
    oprot.writeFieldStop()
18624 
    oprot.writeStructEnd()
18625 
 
18626 
  def validate(self):
18627 
    return
18628 
 
18629 
 
18630 
  def __repr__(self):
18631 
    L = ['%s=%r' % (key, value)
18632 
      for key, value in self.__dict__.iteritems()]
18633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18634 
 
18635 
  def __eq__(self, other):
18636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18637 
 
18638 
  def __ne__(self, other):
18639 
    return not (self == other)
4008 mandeep.dh 18640 
 
18641 
class getTransactionsRequiringExtraProcessing_args:
18642 
  """
18643 
  Attributes:
18644 
   - category
18645 
  """
18646 
 
18647 
  thrift_spec = (
18648 
    None, # 0
18649 
    (1, TType.I32, 'category', None, None, ), # 1
18650 
  )
18651 
 
18652 
  def __init__(self, category=None,):
18653 
    self.category = category
18654 
 
18655 
  def read(self, iprot):
18656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18658 
      return
18659 
    iprot.readStructBegin()
18660 
    while True:
18661 
      (fname, ftype, fid) = iprot.readFieldBegin()
18662 
      if ftype == TType.STOP:
18663 
        break
18664 
      if fid == 1:
18665 
        if ftype == TType.I32:
18666 
          self.category = iprot.readI32();
18667 
        else:
18668 
          iprot.skip(ftype)
18669 
      else:
18670 
        iprot.skip(ftype)
18671 
      iprot.readFieldEnd()
18672 
    iprot.readStructEnd()
18673 
 
18674 
  def write(self, oprot):
18675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18677 
      return
18678 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
18679 
    if self.category is not None:
18680 
      oprot.writeFieldBegin('category', TType.I32, 1)
18681 
      oprot.writeI32(self.category)
18682 
      oprot.writeFieldEnd()
18683 
    oprot.writeFieldStop()
18684 
    oprot.writeStructEnd()
18685 
 
18686 
  def validate(self):
18687 
    return
18688 
 
18689 
 
18690 
  def __repr__(self):
18691 
    L = ['%s=%r' % (key, value)
18692 
      for key, value in self.__dict__.iteritems()]
18693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18694 
 
18695 
  def __eq__(self, other):
18696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18697 
 
18698 
  def __ne__(self, other):
18699 
    return not (self == other)
18700 
 
18701 
class getTransactionsRequiringExtraProcessing_result:
18702 
  """
18703 
  Attributes:
18704 
   - success
18705 
  """
18706 
 
18707 
  thrift_spec = (
18708 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
18709 
  )
18710 
 
18711 
  def __init__(self, success=None,):
18712 
    self.success = success
18713 
 
18714 
  def read(self, iprot):
18715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18717 
      return
18718 
    iprot.readStructBegin()
18719 
    while True:
18720 
      (fname, ftype, fid) = iprot.readFieldBegin()
18721 
      if ftype == TType.STOP:
18722 
        break
18723 
      if fid == 0:
18724 
        if ftype == TType.LIST:
18725 
          self.success = []
5713 rajveer 18726 
          (_etype431, _size428) = iprot.readListBegin()
18727 
          for _i432 in xrange(_size428):
18728 
            _elem433 = iprot.readI64();
18729 
            self.success.append(_elem433)
4008 mandeep.dh 18730 
          iprot.readListEnd()
18731 
        else:
18732 
          iprot.skip(ftype)
18733 
      else:
18734 
        iprot.skip(ftype)
18735 
      iprot.readFieldEnd()
18736 
    iprot.readStructEnd()
18737 
 
18738 
  def write(self, oprot):
18739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18741 
      return
18742 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
18743 
    if self.success is not None:
18744 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18745 
      oprot.writeListBegin(TType.I64, len(self.success))
5713 rajveer 18746 
      for iter434 in self.success:
18747 
        oprot.writeI64(iter434)
4008 mandeep.dh 18748 
      oprot.writeListEnd()
18749 
      oprot.writeFieldEnd()
18750 
    oprot.writeFieldStop()
18751 
    oprot.writeStructEnd()
18752 
 
18753 
  def validate(self):
18754 
    return
18755 
 
18756 
 
18757 
  def __repr__(self):
18758 
    L = ['%s=%r' % (key, value)
18759 
      for key, value in self.__dict__.iteritems()]
18760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18761 
 
18762 
  def __eq__(self, other):
18763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18764 
 
18765 
  def __ne__(self, other):
18766 
    return not (self == other)
18767 
 
18768 
class markTransactionAsProcessed_args:
18769 
  """
18770 
  Attributes:
18771 
   - transactionId
18772 
   - category
18773 
  """
18774 
 
18775 
  thrift_spec = (
18776 
    None, # 0
18777 
    (1, TType.I64, 'transactionId', None, None, ), # 1
18778 
    (2, TType.I32, 'category', None, None, ), # 2
18779 
  )
18780 
 
18781 
  def __init__(self, transactionId=None, category=None,):
18782 
    self.transactionId = transactionId
18783 
    self.category = category
18784 
 
18785 
  def read(self, iprot):
18786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18788 
      return
18789 
    iprot.readStructBegin()
18790 
    while True:
18791 
      (fname, ftype, fid) = iprot.readFieldBegin()
18792 
      if ftype == TType.STOP:
18793 
        break
18794 
      if fid == 1:
18795 
        if ftype == TType.I64:
18796 
          self.transactionId = iprot.readI64();
18797 
        else:
18798 
          iprot.skip(ftype)
18799 
      elif fid == 2:
18800 
        if ftype == TType.I32:
18801 
          self.category = iprot.readI32();
18802 
        else:
18803 
          iprot.skip(ftype)
18804 
      else:
18805 
        iprot.skip(ftype)
18806 
      iprot.readFieldEnd()
18807 
    iprot.readStructEnd()
18808 
 
18809 
  def write(self, oprot):
18810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18812 
      return
18813 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
18814 
    if self.transactionId is not None:
18815 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
18816 
      oprot.writeI64(self.transactionId)
18817 
      oprot.writeFieldEnd()
18818 
    if self.category is not None:
18819 
      oprot.writeFieldBegin('category', TType.I32, 2)
18820 
      oprot.writeI32(self.category)
18821 
      oprot.writeFieldEnd()
18822 
    oprot.writeFieldStop()
18823 
    oprot.writeStructEnd()
18824 
 
18825 
  def validate(self):
18826 
    return
18827 
 
18828 
 
18829 
  def __repr__(self):
18830 
    L = ['%s=%r' % (key, value)
18831 
      for key, value in self.__dict__.iteritems()]
18832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18833 
 
18834 
  def __eq__(self, other):
18835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18836 
 
18837 
  def __ne__(self, other):
18838 
    return not (self == other)
18839 
 
18840 
class markTransactionAsProcessed_result:
18841 
 
18842 
  thrift_spec = (
18843 
  )
18844 
 
18845 
  def read(self, iprot):
18846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18848 
      return
18849 
    iprot.readStructBegin()
18850 
    while True:
18851 
      (fname, ftype, fid) = iprot.readFieldBegin()
18852 
      if ftype == TType.STOP:
18853 
        break
18854 
      else:
18855 
        iprot.skip(ftype)
18856 
      iprot.readFieldEnd()
18857 
    iprot.readStructEnd()
18858 
 
18859 
  def write(self, oprot):
18860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18862 
      return
18863 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
18864 
    oprot.writeFieldStop()
18865 
    oprot.writeStructEnd()
18866 
 
18867 
  def validate(self):
18868 
    return
18869 
 
18870 
 
18871 
  def __repr__(self):
18872 
    L = ['%s=%r' % (key, value)
18873 
      for key, value in self.__dict__.iteritems()]
18874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18875 
 
18876 
  def __eq__(self, other):
18877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18878 
 
18879 
  def __ne__(self, other):
18880 
    return not (self == other)
4018 chandransh 18881 
 
18882 
class getItemWiseRiskyOrdersCount_args:
18883 
 
18884 
  thrift_spec = (
18885 
  )
18886 
 
18887 
  def read(self, iprot):
18888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18890 
      return
18891 
    iprot.readStructBegin()
18892 
    while True:
18893 
      (fname, ftype, fid) = iprot.readFieldBegin()
18894 
      if ftype == TType.STOP:
18895 
        break
18896 
      else:
18897 
        iprot.skip(ftype)
18898 
      iprot.readFieldEnd()
18899 
    iprot.readStructEnd()
18900 
 
18901 
  def write(self, oprot):
18902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18904 
      return
18905 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
18906 
    oprot.writeFieldStop()
18907 
    oprot.writeStructEnd()
18908 
 
18909 
  def validate(self):
18910 
    return
18911 
 
18912 
 
18913 
  def __repr__(self):
18914 
    L = ['%s=%r' % (key, value)
18915 
      for key, value in self.__dict__.iteritems()]
18916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18917 
 
18918 
  def __eq__(self, other):
18919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18920 
 
18921 
  def __ne__(self, other):
18922 
    return not (self == other)
18923 
 
18924 
class getItemWiseRiskyOrdersCount_result:
18925 
  """
18926 
  Attributes:
18927 
   - success
18928 
  """
18929 
 
18930 
  thrift_spec = (
18931 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
18932 
  )
18933 
 
18934 
  def __init__(self, success=None,):
18935 
    self.success = success
18936 
 
18937 
  def read(self, iprot):
18938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18940 
      return
18941 
    iprot.readStructBegin()
18942 
    while True:
18943 
      (fname, ftype, fid) = iprot.readFieldBegin()
18944 
      if ftype == TType.STOP:
18945 
        break
18946 
      if fid == 0:
18947 
        if ftype == TType.MAP:
18948 
          self.success = {}
5713 rajveer 18949 
          (_ktype436, _vtype437, _size435 ) = iprot.readMapBegin()
18950 
          for _i439 in xrange(_size435):
18951 
            _key440 = iprot.readI64();
18952 
            _val441 = iprot.readI64();
18953 
            self.success[_key440] = _val441
4018 chandransh 18954 
          iprot.readMapEnd()
18955 
        else:
18956 
          iprot.skip(ftype)
18957 
      else:
18958 
        iprot.skip(ftype)
18959 
      iprot.readFieldEnd()
18960 
    iprot.readStructEnd()
18961 
 
18962 
  def write(self, oprot):
18963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18965 
      return
18966 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
18967 
    if self.success is not None:
18968 
      oprot.writeFieldBegin('success', TType.MAP, 0)
18969 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5713 rajveer 18970 
      for kiter442,viter443 in self.success.items():
18971 
        oprot.writeI64(kiter442)
18972 
        oprot.writeI64(viter443)
4018 chandransh 18973 
      oprot.writeMapEnd()
18974 
      oprot.writeFieldEnd()
18975 
    oprot.writeFieldStop()
18976 
    oprot.writeStructEnd()
18977 
 
18978 
  def validate(self):
18979 
    return
18980 
 
18981 
 
18982 
  def __repr__(self):
18983 
    L = ['%s=%r' % (key, value)
18984 
      for key, value in self.__dict__.iteritems()]
18985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18986 
 
18987 
  def __eq__(self, other):
18988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18989 
 
18990 
  def __ne__(self, other):
18991 
    return not (self == other)
4247 rajveer 18992 
 
4295 varun.gupt 18993 
class getOrdersForItemIds_args:
18994 
  """
18995 
  Attributes:
18996 
   - itemIds
18997 
  """
18998 
 
18999 
  thrift_spec = (
19000 
    None, # 0
19001 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19002 
  )
19003 
 
19004 
  def __init__(self, itemIds=None,):
19005 
    self.itemIds = itemIds
19006 
 
19007 
  def read(self, iprot):
19008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19010 
      return
19011 
    iprot.readStructBegin()
19012 
    while True:
19013 
      (fname, ftype, fid) = iprot.readFieldBegin()
19014 
      if ftype == TType.STOP:
19015 
        break
19016 
      if fid == 1:
19017 
        if ftype == TType.LIST:
19018 
          self.itemIds = []
5713 rajveer 19019 
          (_etype447, _size444) = iprot.readListBegin()
19020 
          for _i448 in xrange(_size444):
19021 
            _elem449 = iprot.readI64();
19022 
            self.itemIds.append(_elem449)
4295 varun.gupt 19023 
          iprot.readListEnd()
19024 
        else:
19025 
          iprot.skip(ftype)
19026 
      else:
19027 
        iprot.skip(ftype)
19028 
      iprot.readFieldEnd()
19029 
    iprot.readStructEnd()
19030 
 
19031 
  def write(self, oprot):
19032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19034 
      return
19035 
    oprot.writeStructBegin('getOrdersForItemIds_args')
19036 
    if self.itemIds is not None:
19037 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19038 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5713 rajveer 19039 
      for iter450 in self.itemIds:
19040 
        oprot.writeI64(iter450)
4295 varun.gupt 19041 
      oprot.writeListEnd()
19042 
      oprot.writeFieldEnd()
19043 
    oprot.writeFieldStop()
19044 
    oprot.writeStructEnd()
19045 
 
19046 
  def validate(self):
19047 
    return
19048 
 
19049 
 
19050 
  def __repr__(self):
19051 
    L = ['%s=%r' % (key, value)
19052 
      for key, value in self.__dict__.iteritems()]
19053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19054 
 
19055 
  def __eq__(self, other):
19056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19057 
 
19058 
  def __ne__(self, other):
19059 
    return not (self == other)
19060 
 
19061 
class getOrdersForItemIds_result:
19062 
  """
19063 
  Attributes:
19064 
   - success
19065 
  """
19066 
 
19067 
  thrift_spec = (
19068 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19069 
  )
19070 
 
19071 
  def __init__(self, success=None,):
19072 
    self.success = success
19073 
 
19074 
  def read(self, iprot):
19075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19077 
      return
19078 
    iprot.readStructBegin()
19079 
    while True:
19080 
      (fname, ftype, fid) = iprot.readFieldBegin()
19081 
      if ftype == TType.STOP:
19082 
        break
19083 
      if fid == 0:
19084 
        if ftype == TType.LIST:
19085 
          self.success = []
5713 rajveer 19086 
          (_etype454, _size451) = iprot.readListBegin()
19087 
          for _i455 in xrange(_size451):
19088 
            _elem456 = Order()
19089 
            _elem456.read(iprot)
19090 
            self.success.append(_elem456)
4295 varun.gupt 19091 
          iprot.readListEnd()
19092 
        else:
19093 
          iprot.skip(ftype)
19094 
      else:
19095 
        iprot.skip(ftype)
19096 
      iprot.readFieldEnd()
19097 
    iprot.readStructEnd()
19098 
 
19099 
  def write(self, oprot):
19100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19102 
      return
19103 
    oprot.writeStructBegin('getOrdersForItemIds_result')
19104 
    if self.success is not None:
19105 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19106 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 19107 
      for iter457 in self.success:
19108 
        iter457.write(oprot)
4295 varun.gupt 19109 
      oprot.writeListEnd()
19110 
      oprot.writeFieldEnd()
19111 
    oprot.writeFieldStop()
19112 
    oprot.writeStructEnd()
19113 
 
19114 
  def validate(self):
19115 
    return
19116 
 
19117 
 
19118 
  def __repr__(self):
19119 
    L = ['%s=%r' % (key, value)
19120 
      for key, value in self.__dict__.iteritems()]
19121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19122 
 
19123 
  def __eq__(self, other):
19124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19125 
 
19126 
  def __ne__(self, other):
19127 
    return not (self == other)
19128 
 
4247 rajveer 19129 
class markOrderCancellationRequestReceived_args:
19130 
  """
19131 
  Attributes:
19132 
   - orderId
19133 
  """
19134 
 
19135 
  thrift_spec = (
19136 
    None, # 0
19137 
    (1, TType.I64, 'orderId', None, None, ), # 1
19138 
  )
19139 
 
19140 
  def __init__(self, orderId=None,):
19141 
    self.orderId = orderId
19142 
 
19143 
  def read(self, iprot):
19144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19146 
      return
19147 
    iprot.readStructBegin()
19148 
    while True:
19149 
      (fname, ftype, fid) = iprot.readFieldBegin()
19150 
      if ftype == TType.STOP:
19151 
        break
19152 
      if fid == 1:
19153 
        if ftype == TType.I64:
19154 
          self.orderId = iprot.readI64();
19155 
        else:
19156 
          iprot.skip(ftype)
19157 
      else:
19158 
        iprot.skip(ftype)
19159 
      iprot.readFieldEnd()
19160 
    iprot.readStructEnd()
19161 
 
19162 
  def write(self, oprot):
19163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19165 
      return
19166 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
19167 
    if self.orderId is not None:
19168 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19169 
      oprot.writeI64(self.orderId)
19170 
      oprot.writeFieldEnd()
19171 
    oprot.writeFieldStop()
19172 
    oprot.writeStructEnd()
19173 
 
19174 
  def validate(self):
19175 
    return
19176 
 
19177 
 
19178 
  def __repr__(self):
19179 
    L = ['%s=%r' % (key, value)
19180 
      for key, value in self.__dict__.iteritems()]
19181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19182 
 
19183 
  def __eq__(self, other):
19184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19185 
 
19186 
  def __ne__(self, other):
19187 
    return not (self == other)
19188 
 
19189 
class markOrderCancellationRequestReceived_result:
19190 
  """
19191 
  Attributes:
19192 
   - ex
19193 
  """
19194 
 
19195 
  thrift_spec = (
19196 
    None, # 0
19197 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19198 
  )
19199 
 
19200 
  def __init__(self, ex=None,):
19201 
    self.ex = ex
19202 
 
19203 
  def read(self, iprot):
19204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19206 
      return
19207 
    iprot.readStructBegin()
19208 
    while True:
19209 
      (fname, ftype, fid) = iprot.readFieldBegin()
19210 
      if ftype == TType.STOP:
19211 
        break
19212 
      if fid == 1:
19213 
        if ftype == TType.STRUCT:
19214 
          self.ex = TransactionServiceException()
19215 
          self.ex.read(iprot)
19216 
        else:
19217 
          iprot.skip(ftype)
19218 
      else:
19219 
        iprot.skip(ftype)
19220 
      iprot.readFieldEnd()
19221 
    iprot.readStructEnd()
19222 
 
19223 
  def write(self, oprot):
19224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19226 
      return
19227 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
19228 
    if self.ex is not None:
19229 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19230 
      self.ex.write(oprot)
19231 
      oprot.writeFieldEnd()
19232 
    oprot.writeFieldStop()
19233 
    oprot.writeStructEnd()
19234 
 
19235 
  def validate(self):
19236 
    return
19237 
 
19238 
 
19239 
  def __repr__(self):
19240 
    L = ['%s=%r' % (key, value)
19241 
      for key, value in self.__dict__.iteritems()]
19242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19243 
 
19244 
  def __eq__(self, other):
19245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19246 
 
19247 
  def __ne__(self, other):
19248 
    return not (self == other)
19249 
 
19250 
class markOrderCancellationRequestConfirmed_args:
19251 
  """
19252 
  Attributes:
19253 
   - orderId
19254 
  """
19255 
 
19256 
  thrift_spec = (
19257 
    None, # 0
19258 
    (1, TType.I64, 'orderId', None, None, ), # 1
19259 
  )
19260 
 
19261 
  def __init__(self, orderId=None,):
19262 
    self.orderId = orderId
19263 
 
19264 
  def read(self, iprot):
19265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19267 
      return
19268 
    iprot.readStructBegin()
19269 
    while True:
19270 
      (fname, ftype, fid) = iprot.readFieldBegin()
19271 
      if ftype == TType.STOP:
19272 
        break
19273 
      if fid == 1:
19274 
        if ftype == TType.I64:
19275 
          self.orderId = iprot.readI64();
19276 
        else:
19277 
          iprot.skip(ftype)
19278 
      else:
19279 
        iprot.skip(ftype)
19280 
      iprot.readFieldEnd()
19281 
    iprot.readStructEnd()
19282 
 
19283 
  def write(self, oprot):
19284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19286 
      return
19287 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
19288 
    if self.orderId is not None:
19289 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19290 
      oprot.writeI64(self.orderId)
19291 
      oprot.writeFieldEnd()
19292 
    oprot.writeFieldStop()
19293 
    oprot.writeStructEnd()
19294 
 
19295 
  def validate(self):
19296 
    return
19297 
 
19298 
 
19299 
  def __repr__(self):
19300 
    L = ['%s=%r' % (key, value)
19301 
      for key, value in self.__dict__.iteritems()]
19302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19303 
 
19304 
  def __eq__(self, other):
19305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19306 
 
19307 
  def __ne__(self, other):
19308 
    return not (self == other)
19309 
 
19310 
class markOrderCancellationRequestConfirmed_result:
19311 
  """
19312 
  Attributes:
19313 
   - ex
19314 
  """
19315 
 
19316 
  thrift_spec = (
19317 
    None, # 0
19318 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19319 
  )
19320 
 
19321 
  def __init__(self, ex=None,):
19322 
    self.ex = ex
19323 
 
19324 
  def read(self, iprot):
19325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19327 
      return
19328 
    iprot.readStructBegin()
19329 
    while True:
19330 
      (fname, ftype, fid) = iprot.readFieldBegin()
19331 
      if ftype == TType.STOP:
19332 
        break
19333 
      if fid == 1:
19334 
        if ftype == TType.STRUCT:
19335 
          self.ex = TransactionServiceException()
19336 
          self.ex.read(iprot)
19337 
        else:
19338 
          iprot.skip(ftype)
19339 
      else:
19340 
        iprot.skip(ftype)
19341 
      iprot.readFieldEnd()
19342 
    iprot.readStructEnd()
19343 
 
19344 
  def write(self, oprot):
19345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19347 
      return
19348 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
19349 
    if self.ex is not None:
19350 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19351 
      self.ex.write(oprot)
19352 
      oprot.writeFieldEnd()
19353 
    oprot.writeFieldStop()
19354 
    oprot.writeStructEnd()
19355 
 
19356 
  def validate(self):
19357 
    return
19358 
 
19359 
 
19360 
  def __repr__(self):
19361 
    L = ['%s=%r' % (key, value)
19362 
      for key, value in self.__dict__.iteritems()]
19363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19364 
 
19365 
  def __eq__(self, other):
19366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19367 
 
19368 
  def __ne__(self, other):
19369 
    return not (self == other)
19370 
 
19371 
class markOrderCancellationRequestDenied_args:
19372 
  """
19373 
  Attributes:
19374 
   - orderId
19375 
  """
19376 
 
19377 
  thrift_spec = (
19378 
    None, # 0
19379 
    (1, TType.I64, 'orderId', None, None, ), # 1
19380 
  )
19381 
 
19382 
  def __init__(self, orderId=None,):
19383 
    self.orderId = orderId
19384 
 
19385 
  def read(self, iprot):
19386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19388 
      return
19389 
    iprot.readStructBegin()
19390 
    while True:
19391 
      (fname, ftype, fid) = iprot.readFieldBegin()
19392 
      if ftype == TType.STOP:
19393 
        break
19394 
      if fid == 1:
19395 
        if ftype == TType.I64:
19396 
          self.orderId = iprot.readI64();
19397 
        else:
19398 
          iprot.skip(ftype)
19399 
      else:
19400 
        iprot.skip(ftype)
19401 
      iprot.readFieldEnd()
19402 
    iprot.readStructEnd()
19403 
 
19404 
  def write(self, oprot):
19405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19407 
      return
19408 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
19409 
    if self.orderId is not None:
19410 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19411 
      oprot.writeI64(self.orderId)
19412 
      oprot.writeFieldEnd()
19413 
    oprot.writeFieldStop()
19414 
    oprot.writeStructEnd()
19415 
 
19416 
  def validate(self):
19417 
    return
19418 
 
19419 
 
19420 
  def __repr__(self):
19421 
    L = ['%s=%r' % (key, value)
19422 
      for key, value in self.__dict__.iteritems()]
19423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19424 
 
19425 
  def __eq__(self, other):
19426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19427 
 
19428 
  def __ne__(self, other):
19429 
    return not (self == other)
19430 
 
19431 
class markOrderCancellationRequestDenied_result:
19432 
  """
19433 
  Attributes:
19434 
   - ex
19435 
  """
19436 
 
19437 
  thrift_spec = (
19438 
    None, # 0
19439 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19440 
  )
19441 
 
19442 
  def __init__(self, ex=None,):
19443 
    self.ex = ex
19444 
 
19445 
  def read(self, iprot):
19446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19448 
      return
19449 
    iprot.readStructBegin()
19450 
    while True:
19451 
      (fname, ftype, fid) = iprot.readFieldBegin()
19452 
      if ftype == TType.STOP:
19453 
        break
19454 
      if fid == 1:
19455 
        if ftype == TType.STRUCT:
19456 
          self.ex = TransactionServiceException()
19457 
          self.ex.read(iprot)
19458 
        else:
19459 
          iprot.skip(ftype)
19460 
      else:
19461 
        iprot.skip(ftype)
19462 
      iprot.readFieldEnd()
19463 
    iprot.readStructEnd()
19464 
 
19465 
  def write(self, oprot):
19466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19468 
      return
19469 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
19470 
    if self.ex is not None:
19471 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19472 
      self.ex.write(oprot)
19473 
      oprot.writeFieldEnd()
19474 
    oprot.writeFieldStop()
19475 
    oprot.writeStructEnd()
19476 
 
19477 
  def validate(self):
19478 
    return
19479 
 
19480 
 
19481 
  def __repr__(self):
19482 
    L = ['%s=%r' % (key, value)
19483 
      for key, value in self.__dict__.iteritems()]
19484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19485 
 
19486 
  def __eq__(self, other):
19487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19488 
 
19489 
  def __ne__(self, other):
19490 
    return not (self == other)
19491 
 
4258 rajveer 19492 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 19493 
  """
19494 
  Attributes:
4258 rajveer 19495 
   - transactionId
4247 rajveer 19496 
  """
19497 
 
19498 
  thrift_spec = (
19499 
    None, # 0
4258 rajveer 19500 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 19501 
  )
19502 
 
4258 rajveer 19503 
  def __init__(self, transactionId=None,):
19504 
    self.transactionId = transactionId
4247 rajveer 19505 
 
19506 
  def read(self, iprot):
19507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19509 
      return
19510 
    iprot.readStructBegin()
19511 
    while True:
19512 
      (fname, ftype, fid) = iprot.readFieldBegin()
19513 
      if ftype == TType.STOP:
19514 
        break
19515 
      if fid == 1:
19516 
        if ftype == TType.I64:
4258 rajveer 19517 
          self.transactionId = iprot.readI64();
4247 rajveer 19518 
        else:
19519 
          iprot.skip(ftype)
19520 
      else:
19521 
        iprot.skip(ftype)
19522 
      iprot.readFieldEnd()
19523 
    iprot.readStructEnd()
19524 
 
19525 
  def write(self, oprot):
19526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19528 
      return
4258 rajveer 19529 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
19530 
    if self.transactionId is not None:
19531 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19532 
      oprot.writeI64(self.transactionId)
4247 rajveer 19533 
      oprot.writeFieldEnd()
19534 
    oprot.writeFieldStop()
19535 
    oprot.writeStructEnd()
19536 
 
19537 
  def validate(self):
19538 
    return
19539 
 
19540 
 
19541 
  def __repr__(self):
19542 
    L = ['%s=%r' % (key, value)
19543 
      for key, value in self.__dict__.iteritems()]
19544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19545 
 
19546 
  def __eq__(self, other):
19547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19548 
 
19549 
  def __ne__(self, other):
19550 
    return not (self == other)
19551 
 
4258 rajveer 19552 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 19553 
  """
19554 
  Attributes:
19555 
   - ex
19556 
  """
19557 
 
19558 
  thrift_spec = (
19559 
    None, # 0
19560 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19561 
  )
19562 
 
19563 
  def __init__(self, ex=None,):
19564 
    self.ex = ex
19565 
 
19566 
  def read(self, iprot):
19567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19569 
      return
19570 
    iprot.readStructBegin()
19571 
    while True:
19572 
      (fname, ftype, fid) = iprot.readFieldBegin()
19573 
      if ftype == TType.STOP:
19574 
        break
19575 
      if fid == 1:
19576 
        if ftype == TType.STRUCT:
19577 
          self.ex = TransactionServiceException()
19578 
          self.ex.read(iprot)
19579 
        else:
19580 
          iprot.skip(ftype)
19581 
      else:
19582 
        iprot.skip(ftype)
19583 
      iprot.readFieldEnd()
19584 
    iprot.readStructEnd()
19585 
 
19586 
  def write(self, oprot):
19587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19589 
      return
4258 rajveer 19590 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 19591 
    if self.ex is not None:
19592 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19593 
      self.ex.write(oprot)
19594 
      oprot.writeFieldEnd()
19595 
    oprot.writeFieldStop()
19596 
    oprot.writeStructEnd()
19597 
 
19598 
  def validate(self):
19599 
    return
19600 
 
19601 
 
19602 
  def __repr__(self):
19603 
    L = ['%s=%r' % (key, value)
19604 
      for key, value in self.__dict__.iteritems()]
19605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19606 
 
19607 
  def __eq__(self, other):
19608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19609 
 
19610 
  def __ne__(self, other):
19611 
    return not (self == other)
4259 anupam.sin 19612 
 
19613 
class refundTransaction_args:
19614 
  """
19615 
  Attributes:
19616 
   - transactionId
19617 
   - refundedBy
19618 
   - reason
19619 
  """
19620 
 
19621 
  thrift_spec = (
19622 
    None, # 0
19623 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19624 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19625 
    (3, TType.STRING, 'reason', None, None, ), # 3
19626 
  )
19627 
 
19628 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
19629 
    self.transactionId = transactionId
19630 
    self.refundedBy = refundedBy
19631 
    self.reason = reason
19632 
 
19633 
  def read(self, iprot):
19634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19636 
      return
19637 
    iprot.readStructBegin()
19638 
    while True:
19639 
      (fname, ftype, fid) = iprot.readFieldBegin()
19640 
      if ftype == TType.STOP:
19641 
        break
19642 
      if fid == 1:
19643 
        if ftype == TType.I64:
19644 
          self.transactionId = iprot.readI64();
19645 
        else:
19646 
          iprot.skip(ftype)
19647 
      elif fid == 2:
19648 
        if ftype == TType.STRING:
19649 
          self.refundedBy = iprot.readString();
19650 
        else:
19651 
          iprot.skip(ftype)
19652 
      elif fid == 3:
19653 
        if ftype == TType.STRING:
19654 
          self.reason = iprot.readString();
19655 
        else:
19656 
          iprot.skip(ftype)
19657 
      else:
19658 
        iprot.skip(ftype)
19659 
      iprot.readFieldEnd()
19660 
    iprot.readStructEnd()
19661 
 
19662 
  def write(self, oprot):
19663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19665 
      return
19666 
    oprot.writeStructBegin('refundTransaction_args')
19667 
    if self.transactionId is not None:
19668 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19669 
      oprot.writeI64(self.transactionId)
19670 
      oprot.writeFieldEnd()
19671 
    if self.refundedBy is not None:
19672 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
19673 
      oprot.writeString(self.refundedBy)
19674 
      oprot.writeFieldEnd()
19675 
    if self.reason is not None:
19676 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
19677 
      oprot.writeString(self.reason)
19678 
      oprot.writeFieldEnd()
19679 
    oprot.writeFieldStop()
19680 
    oprot.writeStructEnd()
19681 
 
19682 
  def validate(self):
19683 
    return
19684 
 
19685 
 
19686 
  def __repr__(self):
19687 
    L = ['%s=%r' % (key, value)
19688 
      for key, value in self.__dict__.iteritems()]
19689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19690 
 
19691 
  def __eq__(self, other):
19692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19693 
 
19694 
  def __ne__(self, other):
19695 
    return not (self == other)
19696 
 
19697 
class refundTransaction_result:
19698 
  """
19699 
  Attributes:
19700 
   - ex
19701 
  """
19702 
 
19703 
  thrift_spec = (
19704 
    None, # 0
19705 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19706 
  )
19707 
 
19708 
  def __init__(self, ex=None,):
19709 
    self.ex = ex
19710 
 
19711 
  def read(self, iprot):
19712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19714 
      return
19715 
    iprot.readStructBegin()
19716 
    while True:
19717 
      (fname, ftype, fid) = iprot.readFieldBegin()
19718 
      if ftype == TType.STOP:
19719 
        break
19720 
      if fid == 1:
19721 
        if ftype == TType.STRUCT:
19722 
          self.ex = TransactionServiceException()
19723 
          self.ex.read(iprot)
19724 
        else:
19725 
          iprot.skip(ftype)
19726 
      else:
19727 
        iprot.skip(ftype)
19728 
      iprot.readFieldEnd()
19729 
    iprot.readStructEnd()
19730 
 
19731 
  def write(self, oprot):
19732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19734 
      return
19735 
    oprot.writeStructBegin('refundTransaction_result')
19736 
    if self.ex is not None:
19737 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19738 
      self.ex.write(oprot)
19739 
      oprot.writeFieldEnd()
19740 
    oprot.writeFieldStop()
19741 
    oprot.writeStructEnd()
19742 
 
19743 
  def validate(self):
19744 
    return
19745 
 
19746 
 
19747 
  def __repr__(self):
19748 
    L = ['%s=%r' % (key, value)
19749 
      for key, value in self.__dict__.iteritems()]
19750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19751 
 
19752 
  def __eq__(self, other):
19753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19754 
 
19755 
  def __ne__(self, other):
19756 
    return not (self == other)
4285 rajveer 19757 
 
4324 mandeep.dh 19758 
class updateShipmentAddress_args:
19759 
  """
19760 
  Attributes:
19761 
   - orderId
19762 
   - addressId
19763 
  """
19764 
 
19765 
  thrift_spec = (
19766 
    None, # 0
19767 
    (1, TType.I64, 'orderId', None, None, ), # 1
19768 
    (2, TType.I64, 'addressId', None, None, ), # 2
19769 
  )
19770 
 
19771 
  def __init__(self, orderId=None, addressId=None,):
19772 
    self.orderId = orderId
19773 
    self.addressId = addressId
19774 
 
19775 
  def read(self, iprot):
19776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19778 
      return
19779 
    iprot.readStructBegin()
19780 
    while True:
19781 
      (fname, ftype, fid) = iprot.readFieldBegin()
19782 
      if ftype == TType.STOP:
19783 
        break
19784 
      if fid == 1:
19785 
        if ftype == TType.I64:
19786 
          self.orderId = iprot.readI64();
19787 
        else:
19788 
          iprot.skip(ftype)
19789 
      elif fid == 2:
19790 
        if ftype == TType.I64:
19791 
          self.addressId = iprot.readI64();
19792 
        else:
19793 
          iprot.skip(ftype)
19794 
      else:
19795 
        iprot.skip(ftype)
19796 
      iprot.readFieldEnd()
19797 
    iprot.readStructEnd()
19798 
 
19799 
  def write(self, oprot):
19800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19802 
      return
19803 
    oprot.writeStructBegin('updateShipmentAddress_args')
19804 
    if self.orderId is not None:
19805 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19806 
      oprot.writeI64(self.orderId)
19807 
      oprot.writeFieldEnd()
19808 
    if self.addressId is not None:
19809 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
19810 
      oprot.writeI64(self.addressId)
19811 
      oprot.writeFieldEnd()
19812 
    oprot.writeFieldStop()
19813 
    oprot.writeStructEnd()
19814 
 
19815 
  def validate(self):
19816 
    return
19817 
 
19818 
 
19819 
  def __repr__(self):
19820 
    L = ['%s=%r' % (key, value)
19821 
      for key, value in self.__dict__.iteritems()]
19822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19823 
 
19824 
  def __eq__(self, other):
19825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19826 
 
19827 
  def __ne__(self, other):
19828 
    return not (self == other)
19829 
 
19830 
class updateShipmentAddress_result:
19831 
  """
19832 
  Attributes:
19833 
   - ex
19834 
  """
19835 
 
19836 
  thrift_spec = (
19837 
    None, # 0
19838 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19839 
  )
19840 
 
19841 
  def __init__(self, ex=None,):
19842 
    self.ex = ex
19843 
 
19844 
  def read(self, iprot):
19845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19847 
      return
19848 
    iprot.readStructBegin()
19849 
    while True:
19850 
      (fname, ftype, fid) = iprot.readFieldBegin()
19851 
      if ftype == TType.STOP:
19852 
        break
19853 
      if fid == 1:
19854 
        if ftype == TType.STRUCT:
19855 
          self.ex = TransactionServiceException()
19856 
          self.ex.read(iprot)
19857 
        else:
19858 
          iprot.skip(ftype)
19859 
      else:
19860 
        iprot.skip(ftype)
19861 
      iprot.readFieldEnd()
19862 
    iprot.readStructEnd()
19863 
 
19864 
  def write(self, oprot):
19865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19867 
      return
19868 
    oprot.writeStructBegin('updateShipmentAddress_result')
19869 
    if self.ex is not None:
19870 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19871 
      self.ex.write(oprot)
19872 
      oprot.writeFieldEnd()
19873 
    oprot.writeFieldStop()
19874 
    oprot.writeStructEnd()
19875 
 
19876 
  def validate(self):
19877 
    return
19878 
 
19879 
 
19880 
  def __repr__(self):
19881 
    L = ['%s=%r' % (key, value)
19882 
      for key, value in self.__dict__.iteritems()]
19883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19884 
 
19885 
  def __eq__(self, other):
19886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19887 
 
19888 
  def __ne__(self, other):
19889 
    return not (self == other)
19890 
 
4285 rajveer 19891 
class acceptOrdersForItemId_args:
19892 
  """
19893 
  Attributes:
19894 
   - itemId
19895 
   - inventory
19896 
  """
19897 
 
19898 
  thrift_spec = (
19899 
    None, # 0
19900 
    (1, TType.I64, 'itemId', None, None, ), # 1
19901 
    (2, TType.I64, 'inventory', None, None, ), # 2
19902 
  )
19903 
 
19904 
  def __init__(self, itemId=None, inventory=None,):
19905 
    self.itemId = itemId
19906 
    self.inventory = inventory
19907 
 
19908 
  def read(self, iprot):
19909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19911 
      return
19912 
    iprot.readStructBegin()
19913 
    while True:
19914 
      (fname, ftype, fid) = iprot.readFieldBegin()
19915 
      if ftype == TType.STOP:
19916 
        break
19917 
      if fid == 1:
19918 
        if ftype == TType.I64:
19919 
          self.itemId = iprot.readI64();
19920 
        else:
19921 
          iprot.skip(ftype)
19922 
      elif fid == 2:
19923 
        if ftype == TType.I64:
19924 
          self.inventory = iprot.readI64();
19925 
        else:
19926 
          iprot.skip(ftype)
19927 
      else:
19928 
        iprot.skip(ftype)
19929 
      iprot.readFieldEnd()
19930 
    iprot.readStructEnd()
19931 
 
19932 
  def write(self, oprot):
19933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19935 
      return
19936 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
19937 
    if self.itemId is not None:
19938 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
19939 
      oprot.writeI64(self.itemId)
19940 
      oprot.writeFieldEnd()
19941 
    if self.inventory is not None:
19942 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
19943 
      oprot.writeI64(self.inventory)
19944 
      oprot.writeFieldEnd()
19945 
    oprot.writeFieldStop()
19946 
    oprot.writeStructEnd()
19947 
 
19948 
  def validate(self):
19949 
    return
19950 
 
19951 
 
19952 
  def __repr__(self):
19953 
    L = ['%s=%r' % (key, value)
19954 
      for key, value in self.__dict__.iteritems()]
19955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19956 
 
19957 
  def __eq__(self, other):
19958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19959 
 
19960 
  def __ne__(self, other):
19961 
    return not (self == other)
19962 
 
19963 
class acceptOrdersForItemId_result:
19964 
  """
19965 
  Attributes:
19966 
   - success
19967 
   - ex
19968 
  """
19969 
 
19970 
  thrift_spec = (
19971 
    (0, TType.BOOL, 'success', None, None, ), # 0
19972 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19973 
  )
19974 
 
19975 
  def __init__(self, success=None, ex=None,):
19976 
    self.success = success
19977 
    self.ex = ex
19978 
 
19979 
  def read(self, iprot):
19980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19982 
      return
19983 
    iprot.readStructBegin()
19984 
    while True:
19985 
      (fname, ftype, fid) = iprot.readFieldBegin()
19986 
      if ftype == TType.STOP:
19987 
        break
19988 
      if fid == 0:
19989 
        if ftype == TType.BOOL:
19990 
          self.success = iprot.readBool();
19991 
        else:
19992 
          iprot.skip(ftype)
19993 
      elif fid == 1:
19994 
        if ftype == TType.STRUCT:
19995 
          self.ex = TransactionServiceException()
19996 
          self.ex.read(iprot)
19997 
        else:
19998 
          iprot.skip(ftype)
19999 
      else:
20000 
        iprot.skip(ftype)
20001 
      iprot.readFieldEnd()
20002 
    iprot.readStructEnd()
20003 
 
20004 
  def write(self, oprot):
20005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20007 
      return
20008 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
20009 
    if self.success is not None:
20010 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20011 
      oprot.writeBool(self.success)
20012 
      oprot.writeFieldEnd()
20013 
    if self.ex is not None:
20014 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20015 
      self.ex.write(oprot)
20016 
      oprot.writeFieldEnd()
20017 
    oprot.writeFieldStop()
20018 
    oprot.writeStructEnd()
20019 
 
20020 
  def validate(self):
20021 
    return
20022 
 
20023 
 
20024 
  def __repr__(self):
20025 
    L = ['%s=%r' % (key, value)
20026 
      for key, value in self.__dict__.iteritems()]
20027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20028 
 
20029 
  def __eq__(self, other):
20030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20031 
 
20032 
  def __ne__(self, other):
20033 
    return not (self == other)
4303 rajveer 20034 
 
20035 
class markOrdersAsPORaised_args:
20036 
  """
20037 
  Attributes:
20038 
   - vendorId
20039 
   - itemId
20040 
   - quantity
20041 
   - estimate
4369 rajveer 20042 
   - isReminder
4303 rajveer 20043 
  """
20044 
 
20045 
  thrift_spec = (
20046 
    None, # 0
20047 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20048 
    (2, TType.I64, 'itemId', None, None, ), # 2
20049 
    (3, TType.I64, 'quantity', None, None, ), # 3
20050 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20051 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20052 
  )
20053 
 
4369 rajveer 20054 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20055 
    self.vendorId = vendorId
20056 
    self.itemId = itemId
20057 
    self.quantity = quantity
20058 
    self.estimate = estimate
4369 rajveer 20059 
    self.isReminder = isReminder
4303 rajveer 20060 
 
20061 
  def read(self, iprot):
20062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20064 
      return
20065 
    iprot.readStructBegin()
20066 
    while True:
20067 
      (fname, ftype, fid) = iprot.readFieldBegin()
20068 
      if ftype == TType.STOP:
20069 
        break
20070 
      if fid == 1:
20071 
        if ftype == TType.I64:
20072 
          self.vendorId = iprot.readI64();
20073 
        else:
20074 
          iprot.skip(ftype)
20075 
      elif fid == 2:
20076 
        if ftype == TType.I64:
20077 
          self.itemId = iprot.readI64();
20078 
        else:
20079 
          iprot.skip(ftype)
20080 
      elif fid == 3:
20081 
        if ftype == TType.I64:
20082 
          self.quantity = iprot.readI64();
20083 
        else:
20084 
          iprot.skip(ftype)
20085 
      elif fid == 4:
20086 
        if ftype == TType.I64:
20087 
          self.estimate = iprot.readI64();
20088 
        else:
20089 
          iprot.skip(ftype)
4369 rajveer 20090 
      elif fid == 5:
20091 
        if ftype == TType.BOOL:
20092 
          self.isReminder = iprot.readBool();
20093 
        else:
20094 
          iprot.skip(ftype)
4303 rajveer 20095 
      else:
20096 
        iprot.skip(ftype)
20097 
      iprot.readFieldEnd()
20098 
    iprot.readStructEnd()
20099 
 
20100 
  def write(self, oprot):
20101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20103 
      return
20104 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
20105 
    if self.vendorId is not None:
20106 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20107 
      oprot.writeI64(self.vendorId)
20108 
      oprot.writeFieldEnd()
20109 
    if self.itemId is not None:
20110 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20111 
      oprot.writeI64(self.itemId)
20112 
      oprot.writeFieldEnd()
20113 
    if self.quantity is not None:
20114 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20115 
      oprot.writeI64(self.quantity)
20116 
      oprot.writeFieldEnd()
20117 
    if self.estimate is not None:
20118 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20119 
      oprot.writeI64(self.estimate)
20120 
      oprot.writeFieldEnd()
4369 rajveer 20121 
    if self.isReminder is not None:
20122 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20123 
      oprot.writeBool(self.isReminder)
20124 
      oprot.writeFieldEnd()
4303 rajveer 20125 
    oprot.writeFieldStop()
20126 
    oprot.writeStructEnd()
20127 
 
20128 
  def validate(self):
20129 
    return
20130 
 
20131 
 
20132 
  def __repr__(self):
20133 
    L = ['%s=%r' % (key, value)
20134 
      for key, value in self.__dict__.iteritems()]
20135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20136 
 
20137 
  def __eq__(self, other):
20138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20139 
 
20140 
  def __ne__(self, other):
20141 
    return not (self == other)
20142 
 
20143 
class markOrdersAsPORaised_result:
20144 
  """
20145 
  Attributes:
20146 
   - ex
20147 
  """
20148 
 
20149 
  thrift_spec = (
20150 
    None, # 0
20151 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20152 
  )
20153 
 
20154 
  def __init__(self, ex=None,):
20155 
    self.ex = ex
20156 
 
20157 
  def read(self, iprot):
20158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20160 
      return
20161 
    iprot.readStructBegin()
20162 
    while True:
20163 
      (fname, ftype, fid) = iprot.readFieldBegin()
20164 
      if ftype == TType.STOP:
20165 
        break
20166 
      if fid == 1:
20167 
        if ftype == TType.STRUCT:
20168 
          self.ex = TransactionServiceException()
20169 
          self.ex.read(iprot)
20170 
        else:
20171 
          iprot.skip(ftype)
20172 
      else:
20173 
        iprot.skip(ftype)
20174 
      iprot.readFieldEnd()
20175 
    iprot.readStructEnd()
20176 
 
20177 
  def write(self, oprot):
20178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20180 
      return
20181 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
20182 
    if self.ex is not None:
20183 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20184 
      self.ex.write(oprot)
20185 
      oprot.writeFieldEnd()
20186 
    oprot.writeFieldStop()
20187 
    oprot.writeStructEnd()
20188 
 
20189 
  def validate(self):
20190 
    return
20191 
 
20192 
 
20193 
  def __repr__(self):
20194 
    L = ['%s=%r' % (key, value)
20195 
      for key, value in self.__dict__.iteritems()]
20196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20197 
 
20198 
  def __eq__(self, other):
20199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20200 
 
20201 
  def __ne__(self, other):
20202 
    return not (self == other)
20203 
 
20204 
class markOrdersAsReversalInitiated_args:
20205 
  """
20206 
  Attributes:
20207 
   - vendorId
20208 
   - itemId
20209 
   - quantity
20210 
   - estimate
4369 rajveer 20211 
   - isReminder
4303 rajveer 20212 
  """
20213 
 
20214 
  thrift_spec = (
20215 
    None, # 0
20216 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20217 
    (2, TType.I64, 'itemId', None, None, ), # 2
20218 
    (3, TType.I64, 'quantity', None, None, ), # 3
20219 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20220 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20221 
  )
20222 
 
4369 rajveer 20223 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20224 
    self.vendorId = vendorId
20225 
    self.itemId = itemId
20226 
    self.quantity = quantity
20227 
    self.estimate = estimate
4369 rajveer 20228 
    self.isReminder = isReminder
4303 rajveer 20229 
 
20230 
  def read(self, iprot):
20231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20233 
      return
20234 
    iprot.readStructBegin()
20235 
    while True:
20236 
      (fname, ftype, fid) = iprot.readFieldBegin()
20237 
      if ftype == TType.STOP:
20238 
        break
20239 
      if fid == 1:
20240 
        if ftype == TType.I64:
20241 
          self.vendorId = iprot.readI64();
20242 
        else:
20243 
          iprot.skip(ftype)
20244 
      elif fid == 2:
20245 
        if ftype == TType.I64:
20246 
          self.itemId = iprot.readI64();
20247 
        else:
20248 
          iprot.skip(ftype)
20249 
      elif fid == 3:
20250 
        if ftype == TType.I64:
20251 
          self.quantity = iprot.readI64();
20252 
        else:
20253 
          iprot.skip(ftype)
20254 
      elif fid == 4:
20255 
        if ftype == TType.I64:
20256 
          self.estimate = iprot.readI64();
20257 
        else:
20258 
          iprot.skip(ftype)
4369 rajveer 20259 
      elif fid == 5:
20260 
        if ftype == TType.BOOL:
20261 
          self.isReminder = iprot.readBool();
20262 
        else:
20263 
          iprot.skip(ftype)
4303 rajveer 20264 
      else:
20265 
        iprot.skip(ftype)
20266 
      iprot.readFieldEnd()
20267 
    iprot.readStructEnd()
20268 
 
20269 
  def write(self, oprot):
20270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20272 
      return
20273 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
20274 
    if self.vendorId is not None:
20275 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20276 
      oprot.writeI64(self.vendorId)
20277 
      oprot.writeFieldEnd()
20278 
    if self.itemId is not None:
20279 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20280 
      oprot.writeI64(self.itemId)
20281 
      oprot.writeFieldEnd()
20282 
    if self.quantity is not None:
20283 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20284 
      oprot.writeI64(self.quantity)
20285 
      oprot.writeFieldEnd()
20286 
    if self.estimate is not None:
20287 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20288 
      oprot.writeI64(self.estimate)
20289 
      oprot.writeFieldEnd()
4369 rajveer 20290 
    if self.isReminder is not None:
20291 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20292 
      oprot.writeBool(self.isReminder)
20293 
      oprot.writeFieldEnd()
4303 rajveer 20294 
    oprot.writeFieldStop()
20295 
    oprot.writeStructEnd()
20296 
 
20297 
  def validate(self):
20298 
    return
20299 
 
20300 
 
20301 
  def __repr__(self):
20302 
    L = ['%s=%r' % (key, value)
20303 
      for key, value in self.__dict__.iteritems()]
20304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20305 
 
20306 
  def __eq__(self, other):
20307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20308 
 
20309 
  def __ne__(self, other):
20310 
    return not (self == other)
20311 
 
20312 
class markOrdersAsReversalInitiated_result:
20313 
  """
20314 
  Attributes:
20315 
   - ex
20316 
  """
20317 
 
20318 
  thrift_spec = (
20319 
    None, # 0
20320 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20321 
  )
20322 
 
20323 
  def __init__(self, ex=None,):
20324 
    self.ex = ex
20325 
 
20326 
  def read(self, iprot):
20327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20329 
      return
20330 
    iprot.readStructBegin()
20331 
    while True:
20332 
      (fname, ftype, fid) = iprot.readFieldBegin()
20333 
      if ftype == TType.STOP:
20334 
        break
20335 
      if fid == 1:
20336 
        if ftype == TType.STRUCT:
20337 
          self.ex = TransactionServiceException()
20338 
          self.ex.read(iprot)
20339 
        else:
20340 
          iprot.skip(ftype)
20341 
      else:
20342 
        iprot.skip(ftype)
20343 
      iprot.readFieldEnd()
20344 
    iprot.readStructEnd()
20345 
 
20346 
  def write(self, oprot):
20347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20349 
      return
20350 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
20351 
    if self.ex is not None:
20352 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20353 
      self.ex.write(oprot)
20354 
      oprot.writeFieldEnd()
20355 
    oprot.writeFieldStop()
20356 
    oprot.writeStructEnd()
20357 
 
20358 
  def validate(self):
20359 
    return
20360 
 
20361 
 
20362 
  def __repr__(self):
20363 
    L = ['%s=%r' % (key, value)
20364 
      for key, value in self.__dict__.iteritems()]
20365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20366 
 
20367 
  def __eq__(self, other):
20368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20369 
 
20370 
  def __ne__(self, other):
20371 
    return not (self == other)
20372 
 
20373 
class markOrdersAsNotAvailabke_args:
20374 
  """
20375 
  Attributes:
20376 
   - vendorId
20377 
   - itemId
20378 
   - quantity
20379 
   - estimate
4369 rajveer 20380 
   - isReminder
4303 rajveer 20381 
  """
20382 
 
20383 
  thrift_spec = (
20384 
    None, # 0
20385 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20386 
    (2, TType.I64, 'itemId', None, None, ), # 2
20387 
    (3, TType.I64, 'quantity', None, None, ), # 3
20388 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20389 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20390 
  )
20391 
 
4369 rajveer 20392 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20393 
    self.vendorId = vendorId
20394 
    self.itemId = itemId
20395 
    self.quantity = quantity
20396 
    self.estimate = estimate
4369 rajveer 20397 
    self.isReminder = isReminder
4303 rajveer 20398 
 
20399 
  def read(self, iprot):
20400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20402 
      return
20403 
    iprot.readStructBegin()
20404 
    while True:
20405 
      (fname, ftype, fid) = iprot.readFieldBegin()
20406 
      if ftype == TType.STOP:
20407 
        break
20408 
      if fid == 1:
20409 
        if ftype == TType.I64:
20410 
          self.vendorId = iprot.readI64();
20411 
        else:
20412 
          iprot.skip(ftype)
20413 
      elif fid == 2:
20414 
        if ftype == TType.I64:
20415 
          self.itemId = iprot.readI64();
20416 
        else:
20417 
          iprot.skip(ftype)
20418 
      elif fid == 3:
20419 
        if ftype == TType.I64:
20420 
          self.quantity = iprot.readI64();
20421 
        else:
20422 
          iprot.skip(ftype)
20423 
      elif fid == 4:
20424 
        if ftype == TType.I64:
20425 
          self.estimate = iprot.readI64();
20426 
        else:
20427 
          iprot.skip(ftype)
4369 rajveer 20428 
      elif fid == 5:
20429 
        if ftype == TType.BOOL:
20430 
          self.isReminder = iprot.readBool();
20431 
        else:
20432 
          iprot.skip(ftype)
4303 rajveer 20433 
      else:
20434 
        iprot.skip(ftype)
20435 
      iprot.readFieldEnd()
20436 
    iprot.readStructEnd()
20437 
 
20438 
  def write(self, oprot):
20439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20441 
      return
20442 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
20443 
    if self.vendorId is not None:
20444 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20445 
      oprot.writeI64(self.vendorId)
20446 
      oprot.writeFieldEnd()
20447 
    if self.itemId is not None:
20448 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20449 
      oprot.writeI64(self.itemId)
20450 
      oprot.writeFieldEnd()
20451 
    if self.quantity is not None:
20452 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20453 
      oprot.writeI64(self.quantity)
20454 
      oprot.writeFieldEnd()
20455 
    if self.estimate is not None:
20456 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20457 
      oprot.writeI64(self.estimate)
20458 
      oprot.writeFieldEnd()
4369 rajveer 20459 
    if self.isReminder is not None:
20460 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20461 
      oprot.writeBool(self.isReminder)
20462 
      oprot.writeFieldEnd()
4303 rajveer 20463 
    oprot.writeFieldStop()
20464 
    oprot.writeStructEnd()
20465 
 
20466 
  def validate(self):
20467 
    return
20468 
 
20469 
 
20470 
  def __repr__(self):
20471 
    L = ['%s=%r' % (key, value)
20472 
      for key, value in self.__dict__.iteritems()]
20473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20474 
 
20475 
  def __eq__(self, other):
20476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20477 
 
20478 
  def __ne__(self, other):
20479 
    return not (self == other)
20480 
 
20481 
class markOrdersAsNotAvailabke_result:
20482 
  """
20483 
  Attributes:
20484 
   - ex
20485 
  """
20486 
 
20487 
  thrift_spec = (
20488 
    None, # 0
20489 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20490 
  )
20491 
 
20492 
  def __init__(self, ex=None,):
20493 
    self.ex = ex
20494 
 
20495 
  def read(self, iprot):
20496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20498 
      return
20499 
    iprot.readStructBegin()
20500 
    while True:
20501 
      (fname, ftype, fid) = iprot.readFieldBegin()
20502 
      if ftype == TType.STOP:
20503 
        break
20504 
      if fid == 1:
20505 
        if ftype == TType.STRUCT:
20506 
          self.ex = TransactionServiceException()
20507 
          self.ex.read(iprot)
20508 
        else:
20509 
          iprot.skip(ftype)
20510 
      else:
20511 
        iprot.skip(ftype)
20512 
      iprot.readFieldEnd()
20513 
    iprot.readStructEnd()
20514 
 
20515 
  def write(self, oprot):
20516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20518 
      return
20519 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
20520 
    if self.ex is not None:
20521 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20522 
      self.ex.write(oprot)
20523 
      oprot.writeFieldEnd()
20524 
    oprot.writeFieldStop()
20525 
    oprot.writeStructEnd()
20526 
 
20527 
  def validate(self):
20528 
    return
20529 
 
20530 
 
20531 
  def __repr__(self):
20532 
    L = ['%s=%r' % (key, value)
20533 
      for key, value in self.__dict__.iteritems()]
20534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20535 
 
20536 
  def __eq__(self, other):
20537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20538 
 
20539 
  def __ne__(self, other):
20540 
    return not (self == other)
4369 rajveer 20541 
 
20542 
class markOrdersAsTimeout_args:
20543 
  """
20544 
  Attributes:
20545 
   - vendorId
20546 
  """
20547 
 
20548 
  thrift_spec = (
20549 
    None, # 0
20550 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20551 
  )
20552 
 
20553 
  def __init__(self, vendorId=None,):
20554 
    self.vendorId = vendorId
20555 
 
20556 
  def read(self, iprot):
20557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20559 
      return
20560 
    iprot.readStructBegin()
20561 
    while True:
20562 
      (fname, ftype, fid) = iprot.readFieldBegin()
20563 
      if ftype == TType.STOP:
20564 
        break
20565 
      if fid == 1:
20566 
        if ftype == TType.I64:
20567 
          self.vendorId = iprot.readI64();
20568 
        else:
20569 
          iprot.skip(ftype)
20570 
      else:
20571 
        iprot.skip(ftype)
20572 
      iprot.readFieldEnd()
20573 
    iprot.readStructEnd()
20574 
 
20575 
  def write(self, oprot):
20576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20578 
      return
20579 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
20580 
    if self.vendorId is not None:
20581 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20582 
      oprot.writeI64(self.vendorId)
20583 
      oprot.writeFieldEnd()
20584 
    oprot.writeFieldStop()
20585 
    oprot.writeStructEnd()
20586 
 
20587 
  def validate(self):
20588 
    return
20589 
 
20590 
 
20591 
  def __repr__(self):
20592 
    L = ['%s=%r' % (key, value)
20593 
      for key, value in self.__dict__.iteritems()]
20594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20595 
 
20596 
  def __eq__(self, other):
20597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20598 
 
20599 
  def __ne__(self, other):
20600 
    return not (self == other)
20601 
 
20602 
class markOrdersAsTimeout_result:
20603 
  """
20604 
  Attributes:
20605 
   - success
20606 
   - ex
20607 
  """
20608 
 
20609 
  thrift_spec = (
20610 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
20611 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20612 
  )
20613 
 
20614 
  def __init__(self, success=None, ex=None,):
20615 
    self.success = success
20616 
    self.ex = ex
20617 
 
20618 
  def read(self, iprot):
20619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20621 
      return
20622 
    iprot.readStructBegin()
20623 
    while True:
20624 
      (fname, ftype, fid) = iprot.readFieldBegin()
20625 
      if ftype == TType.STOP:
20626 
        break
20627 
      if fid == 0:
20628 
        if ftype == TType.MAP:
20629 
          self.success = {}
5713 rajveer 20630 
          (_ktype459, _vtype460, _size458 ) = iprot.readMapBegin()
20631 
          for _i462 in xrange(_size458):
20632 
            _key463 = iprot.readI32();
20633 
            _val464 = TimeoutSummary()
20634 
            _val464.read(iprot)
20635 
            self.success[_key463] = _val464
4369 rajveer 20636 
          iprot.readMapEnd()
20637 
        else:
20638 
          iprot.skip(ftype)
20639 
      elif fid == 1:
20640 
        if ftype == TType.STRUCT:
20641 
          self.ex = TransactionServiceException()
20642 
          self.ex.read(iprot)
20643 
        else:
20644 
          iprot.skip(ftype)
20645 
      else:
20646 
        iprot.skip(ftype)
20647 
      iprot.readFieldEnd()
20648 
    iprot.readStructEnd()
20649 
 
20650 
  def write(self, oprot):
20651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20653 
      return
20654 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
20655 
    if self.success is not None:
20656 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20657 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
5713 rajveer 20658 
      for kiter465,viter466 in self.success.items():
20659 
        oprot.writeI32(kiter465)
20660 
        viter466.write(oprot)
4369 rajveer 20661 
      oprot.writeMapEnd()
20662 
      oprot.writeFieldEnd()
20663 
    if self.ex is not None:
20664 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20665 
      self.ex.write(oprot)
20666 
      oprot.writeFieldEnd()
20667 
    oprot.writeFieldStop()
20668 
    oprot.writeStructEnd()
20669 
 
20670 
  def validate(self):
20671 
    return
20672 
 
20673 
 
20674 
  def __repr__(self):
20675 
    L = ['%s=%r' % (key, value)
20676 
      for key, value in self.__dict__.iteritems()]
20677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20678 
 
20679 
  def __eq__(self, other):
20680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20681 
 
20682 
  def __ne__(self, other):
20683 
    return not (self == other)
4386 anupam.sin 20684 
 
4662 rajveer 20685 
class markOrderAsLostInTransit_args:
20686 
  """
20687 
  Attributes:
20688 
   - orderId
20689 
  """
20690 
 
20691 
  thrift_spec = (
20692 
    None, # 0
20693 
    (1, TType.I64, 'orderId', None, None, ), # 1
20694 
  )
20695 
 
20696 
  def __init__(self, orderId=None,):
20697 
    self.orderId = orderId
20698 
 
20699 
  def read(self, iprot):
20700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20702 
      return
20703 
    iprot.readStructBegin()
20704 
    while True:
20705 
      (fname, ftype, fid) = iprot.readFieldBegin()
20706 
      if ftype == TType.STOP:
20707 
        break
20708 
      if fid == 1:
20709 
        if ftype == TType.I64:
20710 
          self.orderId = iprot.readI64();
20711 
        else:
20712 
          iprot.skip(ftype)
20713 
      else:
20714 
        iprot.skip(ftype)
20715 
      iprot.readFieldEnd()
20716 
    iprot.readStructEnd()
20717 
 
20718 
  def write(self, oprot):
20719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20721 
      return
20722 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
20723 
    if self.orderId is not None:
20724 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20725 
      oprot.writeI64(self.orderId)
20726 
      oprot.writeFieldEnd()
20727 
    oprot.writeFieldStop()
20728 
    oprot.writeStructEnd()
20729 
 
20730 
  def validate(self):
20731 
    return
20732 
 
20733 
 
20734 
  def __repr__(self):
20735 
    L = ['%s=%r' % (key, value)
20736 
      for key, value in self.__dict__.iteritems()]
20737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20738 
 
20739 
  def __eq__(self, other):
20740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20741 
 
20742 
  def __ne__(self, other):
20743 
    return not (self == other)
20744 
 
20745 
class markOrderAsLostInTransit_result:
20746 
  """
20747 
  Attributes:
20748 
   - success
20749 
   - ex
20750 
  """
20751 
 
20752 
  thrift_spec = (
20753 
    (0, TType.BOOL, 'success', None, None, ), # 0
20754 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20755 
  )
20756 
 
20757 
  def __init__(self, success=None, ex=None,):
20758 
    self.success = success
20759 
    self.ex = ex
20760 
 
20761 
  def read(self, iprot):
20762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20764 
      return
20765 
    iprot.readStructBegin()
20766 
    while True:
20767 
      (fname, ftype, fid) = iprot.readFieldBegin()
20768 
      if ftype == TType.STOP:
20769 
        break
20770 
      if fid == 0:
20771 
        if ftype == TType.BOOL:
20772 
          self.success = iprot.readBool();
20773 
        else:
20774 
          iprot.skip(ftype)
20775 
      elif fid == 1:
20776 
        if ftype == TType.STRUCT:
20777 
          self.ex = TransactionServiceException()
20778 
          self.ex.read(iprot)
20779 
        else:
20780 
          iprot.skip(ftype)
20781 
      else:
20782 
        iprot.skip(ftype)
20783 
      iprot.readFieldEnd()
20784 
    iprot.readStructEnd()
20785 
 
20786 
  def write(self, oprot):
20787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20789 
      return
20790 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
20791 
    if self.success is not None:
20792 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20793 
      oprot.writeBool(self.success)
20794 
      oprot.writeFieldEnd()
20795 
    if self.ex is not None:
20796 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20797 
      self.ex.write(oprot)
20798 
      oprot.writeFieldEnd()
20799 
    oprot.writeFieldStop()
20800 
    oprot.writeStructEnd()
20801 
 
20802 
  def validate(self):
20803 
    return
20804 
 
20805 
 
20806 
  def __repr__(self):
20807 
    L = ['%s=%r' % (key, value)
20808 
      for key, value in self.__dict__.iteritems()]
20809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20810 
 
20811 
  def __eq__(self, other):
20812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20813 
 
20814 
  def __ne__(self, other):
20815 
    return not (self == other)
20816 
 
4386 anupam.sin 20817 
class getOrderForAwb_args:
20818 
  """
20819 
  Attributes:
20820 
   - awb
20821 
  """
20822 
 
20823 
  thrift_spec = (
20824 
    None, # 0
20825 
    (1, TType.STRING, 'awb', None, None, ), # 1
20826 
  )
20827 
 
20828 
  def __init__(self, awb=None,):
20829 
    self.awb = awb
20830 
 
20831 
  def read(self, iprot):
20832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20834 
      return
20835 
    iprot.readStructBegin()
20836 
    while True:
20837 
      (fname, ftype, fid) = iprot.readFieldBegin()
20838 
      if ftype == TType.STOP:
20839 
        break
20840 
      if fid == 1:
20841 
        if ftype == TType.STRING:
20842 
          self.awb = iprot.readString();
20843 
        else:
20844 
          iprot.skip(ftype)
20845 
      else:
20846 
        iprot.skip(ftype)
20847 
      iprot.readFieldEnd()
20848 
    iprot.readStructEnd()
20849 
 
20850 
  def write(self, oprot):
20851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20853 
      return
20854 
    oprot.writeStructBegin('getOrderForAwb_args')
20855 
    if self.awb is not None:
20856 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
20857 
      oprot.writeString(self.awb)
20858 
      oprot.writeFieldEnd()
20859 
    oprot.writeFieldStop()
20860 
    oprot.writeStructEnd()
20861 
 
20862 
  def validate(self):
20863 
    return
20864 
 
20865 
 
20866 
  def __repr__(self):
20867 
    L = ['%s=%r' % (key, value)
20868 
      for key, value in self.__dict__.iteritems()]
20869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20870 
 
20871 
  def __eq__(self, other):
20872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20873 
 
20874 
  def __ne__(self, other):
20875 
    return not (self == other)
20876 
 
20877 
class getOrderForAwb_result:
20878 
  """
20879 
  Attributes:
20880 
   - success
20881 
   - ex
20882 
  """
20883 
 
20884 
  thrift_spec = (
20885 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20886 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20887 
  )
20888 
 
20889 
  def __init__(self, success=None, ex=None,):
20890 
    self.success = success
20891 
    self.ex = ex
20892 
 
20893 
  def read(self, iprot):
20894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20896 
      return
20897 
    iprot.readStructBegin()
20898 
    while True:
20899 
      (fname, ftype, fid) = iprot.readFieldBegin()
20900 
      if ftype == TType.STOP:
20901 
        break
20902 
      if fid == 0:
20903 
        if ftype == TType.STRUCT:
20904 
          self.success = Order()
20905 
          self.success.read(iprot)
20906 
        else:
20907 
          iprot.skip(ftype)
20908 
      elif fid == 1:
20909 
        if ftype == TType.STRUCT:
20910 
          self.ex = TransactionServiceException()
20911 
          self.ex.read(iprot)
20912 
        else:
20913 
          iprot.skip(ftype)
20914 
      else:
20915 
        iprot.skip(ftype)
20916 
      iprot.readFieldEnd()
20917 
    iprot.readStructEnd()
20918 
 
20919 
  def write(self, oprot):
20920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20922 
      return
20923 
    oprot.writeStructBegin('getOrderForAwb_result')
20924 
    if self.success is not None:
20925 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20926 
      self.success.write(oprot)
20927 
      oprot.writeFieldEnd()
20928 
    if self.ex is not None:
20929 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20930 
      self.ex.write(oprot)
20931 
      oprot.writeFieldEnd()
20932 
    oprot.writeFieldStop()
20933 
    oprot.writeStructEnd()
20934 
 
20935 
  def validate(self):
20936 
    return
20937 
 
20938 
 
20939 
  def __repr__(self):
20940 
    L = ['%s=%r' % (key, value)
20941 
      for key, value in self.__dict__.iteritems()]
20942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20943 
 
20944 
  def __eq__(self, other):
20945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20946 
 
20947 
  def __ne__(self, other):
20948 
    return not (self == other)
4506 phani.kuma 20949 
 
20950 
class getOrdersForProviderForStatus_args:
20951 
  """
20952 
  Attributes:
20953 
   - logistics_provider_id
4910 phani.kuma 20954 
   - order_status_list
4506 phani.kuma 20955 
  """
20956 
 
20957 
  thrift_spec = (
20958 
    None, # 0
20959 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 20960 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 20961 
  )
20962 
 
4910 phani.kuma 20963 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 20964 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 20965 
    self.order_status_list = order_status_list
4506 phani.kuma 20966 
 
20967 
  def read(self, iprot):
20968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20970 
      return
20971 
    iprot.readStructBegin()
20972 
    while True:
20973 
      (fname, ftype, fid) = iprot.readFieldBegin()
20974 
      if ftype == TType.STOP:
20975 
        break
20976 
      if fid == 1:
20977 
        if ftype == TType.I64:
20978 
          self.logistics_provider_id = iprot.readI64();
20979 
        else:
20980 
          iprot.skip(ftype)
20981 
      elif fid == 2:
4910 phani.kuma 20982 
        if ftype == TType.LIST:
20983 
          self.order_status_list = []
5713 rajveer 20984 
          (_etype470, _size467) = iprot.readListBegin()
20985 
          for _i471 in xrange(_size467):
20986 
            _elem472 = iprot.readI32();
20987 
            self.order_status_list.append(_elem472)
4910 phani.kuma 20988 
          iprot.readListEnd()
4506 phani.kuma 20989 
        else:
20990 
          iprot.skip(ftype)
20991 
      else:
20992 
        iprot.skip(ftype)
20993 
      iprot.readFieldEnd()
20994 
    iprot.readStructEnd()
20995 
 
20996 
  def write(self, oprot):
20997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20999 
      return
21000 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
21001 
    if self.logistics_provider_id is not None:
21002 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
21003 
      oprot.writeI64(self.logistics_provider_id)
21004 
      oprot.writeFieldEnd()
4910 phani.kuma 21005 
    if self.order_status_list is not None:
21006 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
21007 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
5713 rajveer 21008 
      for iter473 in self.order_status_list:
21009 
        oprot.writeI32(iter473)
4910 phani.kuma 21010 
      oprot.writeListEnd()
4506 phani.kuma 21011 
      oprot.writeFieldEnd()
21012 
    oprot.writeFieldStop()
21013 
    oprot.writeStructEnd()
21014 
 
21015 
  def validate(self):
21016 
    return
21017 
 
21018 
 
21019 
  def __repr__(self):
21020 
    L = ['%s=%r' % (key, value)
21021 
      for key, value in self.__dict__.iteritems()]
21022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21023 
 
21024 
  def __eq__(self, other):
21025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21026 
 
21027 
  def __ne__(self, other):
21028 
    return not (self == other)
21029 
 
21030 
class getOrdersForProviderForStatus_result:
21031 
  """
21032 
  Attributes:
21033 
   - success
21034 
   - ex
21035 
  """
21036 
 
21037 
  thrift_spec = (
21038 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21039 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21040 
  )
21041 
 
21042 
  def __init__(self, success=None, ex=None,):
21043 
    self.success = success
21044 
    self.ex = ex
21045 
 
21046 
  def read(self, iprot):
21047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21049 
      return
21050 
    iprot.readStructBegin()
21051 
    while True:
21052 
      (fname, ftype, fid) = iprot.readFieldBegin()
21053 
      if ftype == TType.STOP:
21054 
        break
21055 
      if fid == 0:
21056 
        if ftype == TType.LIST:
21057 
          self.success = []
5713 rajveer 21058 
          (_etype477, _size474) = iprot.readListBegin()
21059 
          for _i478 in xrange(_size474):
21060 
            _elem479 = Order()
21061 
            _elem479.read(iprot)
21062 
            self.success.append(_elem479)
4506 phani.kuma 21063 
          iprot.readListEnd()
21064 
        else:
21065 
          iprot.skip(ftype)
21066 
      elif fid == 1:
21067 
        if ftype == TType.STRUCT:
21068 
          self.ex = TransactionServiceException()
21069 
          self.ex.read(iprot)
21070 
        else:
21071 
          iprot.skip(ftype)
21072 
      else:
21073 
        iprot.skip(ftype)
21074 
      iprot.readFieldEnd()
21075 
    iprot.readStructEnd()
21076 
 
21077 
  def write(self, oprot):
21078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21080 
      return
21081 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
21082 
    if self.success is not None:
21083 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21084 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 21085 
      for iter480 in self.success:
21086 
        iter480.write(oprot)
4506 phani.kuma 21087 
      oprot.writeListEnd()
21088 
      oprot.writeFieldEnd()
21089 
    if self.ex is not None:
21090 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21091 
      self.ex.write(oprot)
21092 
      oprot.writeFieldEnd()
21093 
    oprot.writeFieldStop()
21094 
    oprot.writeStructEnd()
21095 
 
21096 
  def validate(self):
21097 
    return
21098 
 
21099 
 
21100 
  def __repr__(self):
21101 
    L = ['%s=%r' % (key, value)
21102 
      for key, value in self.__dict__.iteritems()]
21103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21104 
 
21105 
  def __eq__(self, other):
21106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21107 
 
21108 
  def __ne__(self, other):
21109 
    return not (self == other)
4600 varun.gupt 21110 
 
21111 
class getBilledOrdersForVendor_args:
21112 
  """
21113 
  Attributes:
21114 
   - vendorId
21115 
   - billingDateFrom
21116 
   - billingDateTo
21117 
  """
21118 
 
21119 
  thrift_spec = (
21120 
    None, # 0
21121 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21122 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
21123 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
21124 
  )
21125 
 
21126 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
21127 
    self.vendorId = vendorId
21128 
    self.billingDateFrom = billingDateFrom
21129 
    self.billingDateTo = billingDateTo
21130 
 
21131 
  def read(self, iprot):
21132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21134 
      return
21135 
    iprot.readStructBegin()
21136 
    while True:
21137 
      (fname, ftype, fid) = iprot.readFieldBegin()
21138 
      if ftype == TType.STOP:
21139 
        break
21140 
      if fid == 1:
21141 
        if ftype == TType.I64:
21142 
          self.vendorId = iprot.readI64();
21143 
        else:
21144 
          iprot.skip(ftype)
21145 
      elif fid == 2:
21146 
        if ftype == TType.I64:
21147 
          self.billingDateFrom = iprot.readI64();
21148 
        else:
21149 
          iprot.skip(ftype)
21150 
      elif fid == 3:
21151 
        if ftype == TType.I64:
21152 
          self.billingDateTo = iprot.readI64();
21153 
        else:
21154 
          iprot.skip(ftype)
21155 
      else:
21156 
        iprot.skip(ftype)
21157 
      iprot.readFieldEnd()
21158 
    iprot.readStructEnd()
21159 
 
21160 
  def write(self, oprot):
21161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21163 
      return
21164 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
21165 
    if self.vendorId is not None:
21166 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21167 
      oprot.writeI64(self.vendorId)
21168 
      oprot.writeFieldEnd()
21169 
    if self.billingDateFrom is not None:
21170 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
21171 
      oprot.writeI64(self.billingDateFrom)
21172 
      oprot.writeFieldEnd()
21173 
    if self.billingDateTo is not None:
21174 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
21175 
      oprot.writeI64(self.billingDateTo)
21176 
      oprot.writeFieldEnd()
21177 
    oprot.writeFieldStop()
21178 
    oprot.writeStructEnd()
21179 
 
21180 
  def validate(self):
21181 
    return
21182 
 
21183 
 
21184 
  def __repr__(self):
21185 
    L = ['%s=%r' % (key, value)
21186 
      for key, value in self.__dict__.iteritems()]
21187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21188 
 
21189 
  def __eq__(self, other):
21190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21191 
 
21192 
  def __ne__(self, other):
21193 
    return not (self == other)
21194 
 
21195 
class getBilledOrdersForVendor_result:
21196 
  """
21197 
  Attributes:
21198 
   - success
21199 
   - ex
21200 
  """
21201 
 
21202 
  thrift_spec = (
21203 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21204 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21205 
  )
21206 
 
21207 
  def __init__(self, success=None, ex=None,):
21208 
    self.success = success
21209 
    self.ex = ex
21210 
 
21211 
  def read(self, iprot):
21212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21214 
      return
21215 
    iprot.readStructBegin()
21216 
    while True:
21217 
      (fname, ftype, fid) = iprot.readFieldBegin()
21218 
      if ftype == TType.STOP:
21219 
        break
21220 
      if fid == 0:
21221 
        if ftype == TType.LIST:
21222 
          self.success = []
5713 rajveer 21223 
          (_etype484, _size481) = iprot.readListBegin()
21224 
          for _i485 in xrange(_size481):
21225 
            _elem486 = Order()
21226 
            _elem486.read(iprot)
21227 
            self.success.append(_elem486)
4600 varun.gupt 21228 
          iprot.readListEnd()
21229 
        else:
21230 
          iprot.skip(ftype)
21231 
      elif fid == 1:
21232 
        if ftype == TType.STRUCT:
21233 
          self.ex = TransactionServiceException()
21234 
          self.ex.read(iprot)
21235 
        else:
21236 
          iprot.skip(ftype)
21237 
      else:
21238 
        iprot.skip(ftype)
21239 
      iprot.readFieldEnd()
21240 
    iprot.readStructEnd()
21241 
 
21242 
  def write(self, oprot):
21243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21245 
      return
21246 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
21247 
    if self.success is not None:
21248 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21249 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 21250 
      for iter487 in self.success:
21251 
        iter487.write(oprot)
4600 varun.gupt 21252 
      oprot.writeListEnd()
21253 
      oprot.writeFieldEnd()
21254 
    if self.ex is not None:
21255 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21256 
      self.ex.write(oprot)
21257 
      oprot.writeFieldEnd()
21258 
    oprot.writeFieldStop()
21259 
    oprot.writeStructEnd()
21260 
 
21261 
  def validate(self):
21262 
    return
21263 
 
21264 
 
21265 
  def __repr__(self):
21266 
    L = ['%s=%r' % (key, value)
21267 
      for key, value in self.__dict__.iteritems()]
21268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21269 
 
21270 
  def __eq__(self, other):
21271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21272 
 
21273 
  def __ne__(self, other):
21274 
    return not (self == other)
21275 
 
4607 rajveer 21276 
class getSlippedSippingDateOrders_args:
21277 
 
21278 
  thrift_spec = (
21279 
  )
21280 
 
21281 
  def read(self, iprot):
21282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21284 
      return
21285 
    iprot.readStructBegin()
21286 
    while True:
21287 
      (fname, ftype, fid) = iprot.readFieldBegin()
21288 
      if ftype == TType.STOP:
21289 
        break
21290 
      else:
21291 
        iprot.skip(ftype)
21292 
      iprot.readFieldEnd()
21293 
    iprot.readStructEnd()
21294 
 
21295 
  def write(self, oprot):
21296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21298 
      return
21299 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
21300 
    oprot.writeFieldStop()
21301 
    oprot.writeStructEnd()
21302 
 
21303 
  def validate(self):
21304 
    return
21305 
 
21306 
 
21307 
  def __repr__(self):
21308 
    L = ['%s=%r' % (key, value)
21309 
      for key, value in self.__dict__.iteritems()]
21310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21311 
 
21312 
  def __eq__(self, other):
21313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21314 
 
21315 
  def __ne__(self, other):
21316 
    return not (self == other)
21317 
 
21318 
class getSlippedSippingDateOrders_result:
21319 
  """
21320 
  Attributes:
21321 
   - success
21322 
   - ex
21323 
  """
21324 
 
21325 
  thrift_spec = (
21326 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21327 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21328 
  )
21329 
 
21330 
  def __init__(self, success=None, ex=None,):
21331 
    self.success = success
21332 
    self.ex = ex
21333 
 
21334 
  def read(self, iprot):
21335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21337 
      return
21338 
    iprot.readStructBegin()
21339 
    while True:
21340 
      (fname, ftype, fid) = iprot.readFieldBegin()
21341 
      if ftype == TType.STOP:
21342 
        break
21343 
      if fid == 0:
21344 
        if ftype == TType.LIST:
21345 
          self.success = []
5713 rajveer 21346 
          (_etype491, _size488) = iprot.readListBegin()
21347 
          for _i492 in xrange(_size488):
21348 
            _elem493 = Order()
21349 
            _elem493.read(iprot)
21350 
            self.success.append(_elem493)
4607 rajveer 21351 
          iprot.readListEnd()
21352 
        else:
21353 
          iprot.skip(ftype)
21354 
      elif fid == 1:
21355 
        if ftype == TType.STRUCT:
21356 
          self.ex = TransactionServiceException()
21357 
          self.ex.read(iprot)
21358 
        else:
21359 
          iprot.skip(ftype)
21360 
      else:
21361 
        iprot.skip(ftype)
21362 
      iprot.readFieldEnd()
21363 
    iprot.readStructEnd()
21364 
 
21365 
  def write(self, oprot):
21366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21368 
      return
21369 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
21370 
    if self.success is not None:
21371 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21372 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 21373 
      for iter494 in self.success:
21374 
        iter494.write(oprot)
4607 rajveer 21375 
      oprot.writeListEnd()
21376 
      oprot.writeFieldEnd()
21377 
    if self.ex is not None:
21378 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21379 
      self.ex.write(oprot)
21380 
      oprot.writeFieldEnd()
21381 
    oprot.writeFieldStop()
21382 
    oprot.writeStructEnd()
21383 
 
21384 
  def validate(self):
21385 
    return
21386 
 
21387 
 
21388 
  def __repr__(self):
21389 
    L = ['%s=%r' % (key, value)
21390 
      for key, value in self.__dict__.iteritems()]
21391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21392 
 
21393 
  def __eq__(self, other):
21394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21395 
 
21396 
  def __ne__(self, other):
21397 
    return not (self == other)
21398 
 
4709 rajveer 21399 
class getCancelledOrders_args:
21400 
  """
21401 
  Attributes:
21402 
   - cancelDateFrom
21403 
   - cancelDateTo
21404 
  """
21405 
 
21406 
  thrift_spec = (
21407 
    None, # 0
21408 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
21409 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
21410 
  )
21411 
 
21412 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
21413 
    self.cancelDateFrom = cancelDateFrom
21414 
    self.cancelDateTo = cancelDateTo
21415 
 
21416 
  def read(self, iprot):
21417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21419 
      return
21420 
    iprot.readStructBegin()
21421 
    while True:
21422 
      (fname, ftype, fid) = iprot.readFieldBegin()
21423 
      if ftype == TType.STOP:
21424 
        break
21425 
      if fid == 1:
21426 
        if ftype == TType.I64:
21427 
          self.cancelDateFrom = iprot.readI64();
21428 
        else:
21429 
          iprot.skip(ftype)
21430 
      elif fid == 2:
21431 
        if ftype == TType.I64:
21432 
          self.cancelDateTo = iprot.readI64();
21433 
        else:
21434 
          iprot.skip(ftype)
21435 
      else:
21436 
        iprot.skip(ftype)
21437 
      iprot.readFieldEnd()
21438 
    iprot.readStructEnd()
21439 
 
21440 
  def write(self, oprot):
21441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21443 
      return
21444 
    oprot.writeStructBegin('getCancelledOrders_args')
21445 
    if self.cancelDateFrom is not None:
21446 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
21447 
      oprot.writeI64(self.cancelDateFrom)
21448 
      oprot.writeFieldEnd()
21449 
    if self.cancelDateTo is not None:
21450 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
21451 
      oprot.writeI64(self.cancelDateTo)
21452 
      oprot.writeFieldEnd()
21453 
    oprot.writeFieldStop()
21454 
    oprot.writeStructEnd()
21455 
 
21456 
  def validate(self):
21457 
    return
21458 
 
21459 
 
21460 
  def __repr__(self):
21461 
    L = ['%s=%r' % (key, value)
21462 
      for key, value in self.__dict__.iteritems()]
21463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21464 
 
21465 
  def __eq__(self, other):
21466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21467 
 
21468 
  def __ne__(self, other):
21469 
    return not (self == other)
21470 
 
21471 
class getCancelledOrders_result:
21472 
  """
21473 
  Attributes:
21474 
   - success
21475 
   - ex
21476 
  """
21477 
 
21478 
  thrift_spec = (
21479 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21480 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21481 
  )
21482 
 
21483 
  def __init__(self, success=None, ex=None,):
21484 
    self.success = success
21485 
    self.ex = ex
21486 
 
21487 
  def read(self, iprot):
21488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21490 
      return
21491 
    iprot.readStructBegin()
21492 
    while True:
21493 
      (fname, ftype, fid) = iprot.readFieldBegin()
21494 
      if ftype == TType.STOP:
21495 
        break
21496 
      if fid == 0:
21497 
        if ftype == TType.LIST:
21498 
          self.success = []
5713 rajveer 21499 
          (_etype498, _size495) = iprot.readListBegin()
21500 
          for _i499 in xrange(_size495):
21501 
            _elem500 = Order()
21502 
            _elem500.read(iprot)
21503 
            self.success.append(_elem500)
4709 rajveer 21504 
          iprot.readListEnd()
21505 
        else:
21506 
          iprot.skip(ftype)
21507 
      elif fid == 1:
21508 
        if ftype == TType.STRUCT:
21509 
          self.ex = TransactionServiceException()
21510 
          self.ex.read(iprot)
21511 
        else:
21512 
          iprot.skip(ftype)
21513 
      else:
21514 
        iprot.skip(ftype)
21515 
      iprot.readFieldEnd()
21516 
    iprot.readStructEnd()
21517 
 
21518 
  def write(self, oprot):
21519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21521 
      return
21522 
    oprot.writeStructBegin('getCancelledOrders_result')
21523 
    if self.success is not None:
21524 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21525 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 21526 
      for iter501 in self.success:
21527 
        iter501.write(oprot)
4709 rajveer 21528 
      oprot.writeListEnd()
21529 
      oprot.writeFieldEnd()
21530 
    if self.ex is not None:
21531 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21532 
      self.ex.write(oprot)
21533 
      oprot.writeFieldEnd()
21534 
    oprot.writeFieldStop()
21535 
    oprot.writeStructEnd()
21536 
 
21537 
  def validate(self):
21538 
    return
21539 
 
21540 
 
21541 
  def __repr__(self):
21542 
    L = ['%s=%r' % (key, value)
21543 
      for key, value in self.__dict__.iteritems()]
21544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21545 
 
21546 
  def __eq__(self, other):
21547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21548 
 
21549 
  def __ne__(self, other):
21550 
    return not (self == other)
21551 
 
4600 varun.gupt 21552 
class saveBluedartSettlements_args:
21553 
  """
21554 
  Attributes:
21555 
   - mapAWBAndAmount
21556 
  """
21557 
 
21558 
  thrift_spec = (
21559 
    None, # 0
21560 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
21561 
  )
21562 
 
21563 
  def __init__(self, mapAWBAndAmount=None,):
21564 
    self.mapAWBAndAmount = mapAWBAndAmount
21565 
 
21566 
  def read(self, iprot):
21567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21569 
      return
21570 
    iprot.readStructBegin()
21571 
    while True:
21572 
      (fname, ftype, fid) = iprot.readFieldBegin()
21573 
      if ftype == TType.STOP:
21574 
        break
21575 
      if fid == 1:
21576 
        if ftype == TType.MAP:
21577 
          self.mapAWBAndAmount = {}
5713 rajveer 21578 
          (_ktype503, _vtype504, _size502 ) = iprot.readMapBegin()
21579 
          for _i506 in xrange(_size502):
21580 
            _key507 = iprot.readI64();
21581 
            _val508 = iprot.readDouble();
21582 
            self.mapAWBAndAmount[_key507] = _val508
4600 varun.gupt 21583 
          iprot.readMapEnd()
21584 
        else:
21585 
          iprot.skip(ftype)
21586 
      else:
21587 
        iprot.skip(ftype)
21588 
      iprot.readFieldEnd()
21589 
    iprot.readStructEnd()
21590 
 
21591 
  def write(self, oprot):
21592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21594 
      return
21595 
    oprot.writeStructBegin('saveBluedartSettlements_args')
21596 
    if self.mapAWBAndAmount is not None:
21597 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
21598 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
5713 rajveer 21599 
      for kiter509,viter510 in self.mapAWBAndAmount.items():
21600 
        oprot.writeI64(kiter509)
21601 
        oprot.writeDouble(viter510)
4600 varun.gupt 21602 
      oprot.writeMapEnd()
21603 
      oprot.writeFieldEnd()
21604 
    oprot.writeFieldStop()
21605 
    oprot.writeStructEnd()
21606 
 
21607 
  def validate(self):
21608 
    return
21609 
 
21610 
 
21611 
  def __repr__(self):
21612 
    L = ['%s=%r' % (key, value)
21613 
      for key, value in self.__dict__.iteritems()]
21614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21615 
 
21616 
  def __eq__(self, other):
21617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21618 
 
21619 
  def __ne__(self, other):
21620 
    return not (self == other)
21621 
 
21622 
class saveBluedartSettlements_result:
21623 
  """
21624 
  Attributes:
21625 
   - ex
21626 
  """
21627 
 
21628 
  thrift_spec = (
21629 
    None, # 0
21630 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21631 
  )
21632 
 
21633 
  def __init__(self, ex=None,):
21634 
    self.ex = ex
21635 
 
21636 
  def read(self, iprot):
21637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21639 
      return
21640 
    iprot.readStructBegin()
21641 
    while True:
21642 
      (fname, ftype, fid) = iprot.readFieldBegin()
21643 
      if ftype == TType.STOP:
21644 
        break
21645 
      if fid == 1:
21646 
        if ftype == TType.STRUCT:
21647 
          self.ex = TransactionServiceException()
21648 
          self.ex.read(iprot)
21649 
        else:
21650 
          iprot.skip(ftype)
21651 
      else:
21652 
        iprot.skip(ftype)
21653 
      iprot.readFieldEnd()
21654 
    iprot.readStructEnd()
21655 
 
21656 
  def write(self, oprot):
21657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21659 
      return
21660 
    oprot.writeStructBegin('saveBluedartSettlements_result')
21661 
    if self.ex is not None:
21662 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21663 
      self.ex.write(oprot)
21664 
      oprot.writeFieldEnd()
21665 
    oprot.writeFieldStop()
21666 
    oprot.writeStructEnd()
21667 
 
21668 
  def validate(self):
21669 
    return
21670 
 
21671 
 
21672 
  def __repr__(self):
21673 
    L = ['%s=%r' % (key, value)
21674 
      for key, value in self.__dict__.iteritems()]
21675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21676 
 
21677 
  def __eq__(self, other):
21678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21679 
 
21680 
  def __ne__(self, other):
21681 
    return not (self == other)
21682 
 
21683 
class savePaymentSettlements_args:
21684 
  """
21685 
  Attributes:
21686 
   - settlementDate
21687 
   - paymentGatewayId
4905 varun.gupt 21688 
   - referenceId
4600 varun.gupt 21689 
   - serviceTax
21690 
   - otherCharges
21691 
   - netCollection
21692 
  """
21693 
 
21694 
  thrift_spec = (
21695 
    None, # 0
21696 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
21697 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 21698 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 21699 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
21700 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
21701 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
21702 
  )
21703 
 
4905 varun.gupt 21704 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 21705 
    self.settlementDate = settlementDate
21706 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 21707 
    self.referenceId = referenceId
4600 varun.gupt 21708 
    self.serviceTax = serviceTax
21709 
    self.otherCharges = otherCharges
21710 
    self.netCollection = netCollection
21711 
 
21712 
  def read(self, iprot):
21713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21715 
      return
21716 
    iprot.readStructBegin()
21717 
    while True:
21718 
      (fname, ftype, fid) = iprot.readFieldBegin()
21719 
      if ftype == TType.STOP:
21720 
        break
21721 
      if fid == 1:
21722 
        if ftype == TType.I64:
21723 
          self.settlementDate = iprot.readI64();
21724 
        else:
21725 
          iprot.skip(ftype)
21726 
      elif fid == 2:
21727 
        if ftype == TType.I64:
21728 
          self.paymentGatewayId = iprot.readI64();
21729 
        else:
21730 
          iprot.skip(ftype)
21731 
      elif fid == 3:
21732 
        if ftype == TType.I64:
4905 varun.gupt 21733 
          self.referenceId = iprot.readI64();
4600 varun.gupt 21734 
        else:
21735 
          iprot.skip(ftype)
21736 
      elif fid == 4:
21737 
        if ftype == TType.DOUBLE:
21738 
          self.serviceTax = iprot.readDouble();
21739 
        else:
21740 
          iprot.skip(ftype)
21741 
      elif fid == 5:
21742 
        if ftype == TType.DOUBLE:
21743 
          self.otherCharges = iprot.readDouble();
21744 
        else:
21745 
          iprot.skip(ftype)
21746 
      elif fid == 6:
21747 
        if ftype == TType.DOUBLE:
21748 
          self.netCollection = iprot.readDouble();
21749 
        else:
21750 
          iprot.skip(ftype)
21751 
      else:
21752 
        iprot.skip(ftype)
21753 
      iprot.readFieldEnd()
21754 
    iprot.readStructEnd()
21755 
 
21756 
  def write(self, oprot):
21757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21759 
      return
21760 
    oprot.writeStructBegin('savePaymentSettlements_args')
21761 
    if self.settlementDate is not None:
21762 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
21763 
      oprot.writeI64(self.settlementDate)
21764 
      oprot.writeFieldEnd()
21765 
    if self.paymentGatewayId is not None:
21766 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
21767 
      oprot.writeI64(self.paymentGatewayId)
21768 
      oprot.writeFieldEnd()
4905 varun.gupt 21769 
    if self.referenceId is not None:
21770 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
21771 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 21772 
      oprot.writeFieldEnd()
21773 
    if self.serviceTax is not None:
21774 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
21775 
      oprot.writeDouble(self.serviceTax)
21776 
      oprot.writeFieldEnd()
21777 
    if self.otherCharges is not None:
21778 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
21779 
      oprot.writeDouble(self.otherCharges)
21780 
      oprot.writeFieldEnd()
21781 
    if self.netCollection is not None:
21782 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
21783 
      oprot.writeDouble(self.netCollection)
21784 
      oprot.writeFieldEnd()
21785 
    oprot.writeFieldStop()
21786 
    oprot.writeStructEnd()
21787 
 
21788 
  def validate(self):
21789 
    return
21790 
 
21791 
 
21792 
  def __repr__(self):
21793 
    L = ['%s=%r' % (key, value)
21794 
      for key, value in self.__dict__.iteritems()]
21795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21796 
 
21797 
  def __eq__(self, other):
21798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21799 
 
21800 
  def __ne__(self, other):
21801 
    return not (self == other)
21802 
 
21803 
class savePaymentSettlements_result:
21804 
  """
21805 
  Attributes:
21806 
   - ex
21807 
  """
21808 
 
21809 
  thrift_spec = (
21810 
    None, # 0
21811 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21812 
  )
21813 
 
21814 
  def __init__(self, ex=None,):
21815 
    self.ex = ex
21816 
 
21817 
  def read(self, iprot):
21818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21820 
      return
21821 
    iprot.readStructBegin()
21822 
    while True:
21823 
      (fname, ftype, fid) = iprot.readFieldBegin()
21824 
      if ftype == TType.STOP:
21825 
        break
21826 
      if fid == 1:
21827 
        if ftype == TType.STRUCT:
21828 
          self.ex = TransactionServiceException()
21829 
          self.ex.read(iprot)
21830 
        else:
21831 
          iprot.skip(ftype)
21832 
      else:
21833 
        iprot.skip(ftype)
21834 
      iprot.readFieldEnd()
21835 
    iprot.readStructEnd()
21836 
 
21837 
  def write(self, oprot):
21838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21840 
      return
21841 
    oprot.writeStructBegin('savePaymentSettlements_result')
21842 
    if self.ex is not None:
21843 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21844 
      self.ex.write(oprot)
21845 
      oprot.writeFieldEnd()
21846 
    oprot.writeFieldStop()
21847 
    oprot.writeStructEnd()
21848 
 
21849 
  def validate(self):
21850 
    return
21851 
 
21852 
 
21853 
  def __repr__(self):
21854 
    L = ['%s=%r' % (key, value)
21855 
      for key, value in self.__dict__.iteritems()]
21856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21857 
 
21858 
  def __eq__(self, other):
21859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21860 
 
21861 
  def __ne__(self, other):
21862 
    return not (self == other)
21863 
 
21864 
class saveEBSSettlementSummary_args:
21865 
  """
21866 
  Attributes:
21867 
   - settlementId
21868 
   - settlementDate
21869 
   - transactionDateFrom
21870 
   - transactionDateTo
21871 
   - amount
21872 
  """
21873 
 
21874 
  thrift_spec = (
21875 
    None, # 0
21876 
    (1, TType.I64, 'settlementId', None, None, ), # 1
21877 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
21878 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
21879 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
21880 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
21881 
  )
21882 
 
21883 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
21884 
    self.settlementId = settlementId
21885 
    self.settlementDate = settlementDate
21886 
    self.transactionDateFrom = transactionDateFrom
21887 
    self.transactionDateTo = transactionDateTo
21888 
    self.amount = amount
21889 
 
21890 
  def read(self, iprot):
21891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21893 
      return
21894 
    iprot.readStructBegin()
21895 
    while True:
21896 
      (fname, ftype, fid) = iprot.readFieldBegin()
21897 
      if ftype == TType.STOP:
21898 
        break
21899 
      if fid == 1:
21900 
        if ftype == TType.I64:
21901 
          self.settlementId = iprot.readI64();
21902 
        else:
21903 
          iprot.skip(ftype)
21904 
      elif fid == 2:
21905 
        if ftype == TType.I64:
21906 
          self.settlementDate = iprot.readI64();
21907 
        else:
21908 
          iprot.skip(ftype)
21909 
      elif fid == 3:
21910 
        if ftype == TType.I64:
21911 
          self.transactionDateFrom = iprot.readI64();
21912 
        else:
21913 
          iprot.skip(ftype)
21914 
      elif fid == 4:
21915 
        if ftype == TType.I64:
21916 
          self.transactionDateTo = iprot.readI64();
21917 
        else:
21918 
          iprot.skip(ftype)
21919 
      elif fid == 5:
21920 
        if ftype == TType.DOUBLE:
21921 
          self.amount = iprot.readDouble();
21922 
        else:
21923 
          iprot.skip(ftype)
21924 
      else:
21925 
        iprot.skip(ftype)
21926 
      iprot.readFieldEnd()
21927 
    iprot.readStructEnd()
21928 
 
21929 
  def write(self, oprot):
21930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21932 
      return
21933 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
21934 
    if self.settlementId is not None:
21935 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
21936 
      oprot.writeI64(self.settlementId)
21937 
      oprot.writeFieldEnd()
21938 
    if self.settlementDate is not None:
21939 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
21940 
      oprot.writeI64(self.settlementDate)
21941 
      oprot.writeFieldEnd()
21942 
    if self.transactionDateFrom is not None:
21943 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
21944 
      oprot.writeI64(self.transactionDateFrom)
21945 
      oprot.writeFieldEnd()
21946 
    if self.transactionDateTo is not None:
21947 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
21948 
      oprot.writeI64(self.transactionDateTo)
21949 
      oprot.writeFieldEnd()
21950 
    if self.amount is not None:
21951 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
21952 
      oprot.writeDouble(self.amount)
21953 
      oprot.writeFieldEnd()
21954 
    oprot.writeFieldStop()
21955 
    oprot.writeStructEnd()
21956 
 
21957 
  def validate(self):
21958 
    return
21959 
 
21960 
 
21961 
  def __repr__(self):
21962 
    L = ['%s=%r' % (key, value)
21963 
      for key, value in self.__dict__.iteritems()]
21964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21965 
 
21966 
  def __eq__(self, other):
21967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21968 
 
21969 
  def __ne__(self, other):
21970 
    return not (self == other)
21971 
 
21972 
class saveEBSSettlementSummary_result:
21973 
  """
21974 
  Attributes:
21975 
   - ex
21976 
  """
21977 
 
21978 
  thrift_spec = (
21979 
    None, # 0
21980 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21981 
  )
21982 
 
21983 
  def __init__(self, ex=None,):
21984 
    self.ex = ex
21985 
 
21986 
  def read(self, iprot):
21987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21989 
      return
21990 
    iprot.readStructBegin()
21991 
    while True:
21992 
      (fname, ftype, fid) = iprot.readFieldBegin()
21993 
      if ftype == TType.STOP:
21994 
        break
21995 
      if fid == 1:
21996 
        if ftype == TType.STRUCT:
21997 
          self.ex = TransactionServiceException()
21998 
          self.ex.read(iprot)
21999 
        else:
22000 
          iprot.skip(ftype)
22001 
      else:
22002 
        iprot.skip(ftype)
22003 
      iprot.readFieldEnd()
22004 
    iprot.readStructEnd()
22005 
 
22006 
  def write(self, oprot):
22007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22009 
      return
22010 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
22011 
    if self.ex is not None:
22012 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22013 
      self.ex.write(oprot)
22014 
      oprot.writeFieldEnd()
22015 
    oprot.writeFieldStop()
22016 
    oprot.writeStructEnd()
22017 
 
22018 
  def validate(self):
22019 
    return
22020 
 
22021 
 
22022 
  def __repr__(self):
22023 
    L = ['%s=%r' % (key, value)
22024 
      for key, value in self.__dict__.iteritems()]
22025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22026 
 
22027 
  def __eq__(self, other):
22028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22029 
 
22030 
  def __ne__(self, other):
22031 
    return not (self == other)
22032 
 
5386 phani.kuma 22033 
class getSettlementForPrepaid_args:
4600 varun.gupt 22034 
  """
22035 
  Attributes:
5189 varun.gupt 22036 
   - referenceId
22037 
   - isRefund
4600 varun.gupt 22038 
  """
22039 
 
22040 
  thrift_spec = (
22041 
    None, # 0
5189 varun.gupt 22042 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 22043 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 22044 
  )
22045 
 
5386 phani.kuma 22046 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 22047 
    self.referenceId = referenceId
22048 
    self.isRefund = isRefund
4600 varun.gupt 22049 
 
22050 
  def read(self, iprot):
22051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22053 
      return
22054 
    iprot.readStructBegin()
22055 
    while True:
22056 
      (fname, ftype, fid) = iprot.readFieldBegin()
22057 
      if ftype == TType.STOP:
22058 
        break
22059 
      if fid == 1:
22060 
        if ftype == TType.I64:
5189 varun.gupt 22061 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22062 
        else:
22063 
          iprot.skip(ftype)
5189 varun.gupt 22064 
      elif fid == 2:
22065 
        if ftype == TType.BOOL:
22066 
          self.isRefund = iprot.readBool();
22067 
        else:
22068 
          iprot.skip(ftype)
4600 varun.gupt 22069 
      else:
22070 
        iprot.skip(ftype)
22071 
      iprot.readFieldEnd()
22072 
    iprot.readStructEnd()
22073 
 
22074 
  def write(self, oprot):
22075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22077 
      return
5386 phani.kuma 22078 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 22079 
    if self.referenceId is not None:
22080 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
22081 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22082 
      oprot.writeFieldEnd()
5386 phani.kuma 22083 
    if self.isRefund is not None:
22084 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
22085 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 22086 
      oprot.writeFieldEnd()
5386 phani.kuma 22087 
    oprot.writeFieldStop()
22088 
    oprot.writeStructEnd()
22089 
 
22090 
  def validate(self):
22091 
    return
22092 
 
22093 
 
22094 
  def __repr__(self):
22095 
    L = ['%s=%r' % (key, value)
22096 
      for key, value in self.__dict__.iteritems()]
22097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22098 
 
22099 
  def __eq__(self, other):
22100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22101 
 
22102 
  def __ne__(self, other):
22103 
    return not (self == other)
22104 
 
22105 
class getSettlementForPrepaid_result:
22106 
  """
22107 
  Attributes:
22108 
   - success
22109 
   - ex
22110 
  """
22111 
 
22112 
  thrift_spec = (
22113 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22114 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22115 
  )
22116 
 
22117 
  def __init__(self, success=None, ex=None,):
22118 
    self.success = success
22119 
    self.ex = ex
22120 
 
22121 
  def read(self, iprot):
22122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22124 
      return
22125 
    iprot.readStructBegin()
22126 
    while True:
22127 
      (fname, ftype, fid) = iprot.readFieldBegin()
22128 
      if ftype == TType.STOP:
22129 
        break
22130 
      if fid == 0:
22131 
        if ftype == TType.STRUCT:
22132 
          self.success = PaymentSettlement()
22133 
          self.success.read(iprot)
22134 
        else:
22135 
          iprot.skip(ftype)
22136 
      elif fid == 1:
22137 
        if ftype == TType.STRUCT:
22138 
          self.ex = TransactionServiceException()
22139 
          self.ex.read(iprot)
22140 
        else:
22141 
          iprot.skip(ftype)
22142 
      else:
22143 
        iprot.skip(ftype)
22144 
      iprot.readFieldEnd()
22145 
    iprot.readStructEnd()
22146 
 
22147 
  def write(self, oprot):
22148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22150 
      return
22151 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
22152 
    if self.success is not None:
22153 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22154 
      self.success.write(oprot)
22155 
      oprot.writeFieldEnd()
22156 
    if self.ex is not None:
22157 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22158 
      self.ex.write(oprot)
22159 
      oprot.writeFieldEnd()
22160 
    oprot.writeFieldStop()
22161 
    oprot.writeStructEnd()
22162 
 
22163 
  def validate(self):
22164 
    return
22165 
 
22166 
 
22167 
  def __repr__(self):
22168 
    L = ['%s=%r' % (key, value)
22169 
      for key, value in self.__dict__.iteritems()]
22170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22171 
 
22172 
  def __eq__(self, other):
22173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22174 
 
22175 
  def __ne__(self, other):
22176 
    return not (self == other)
22177 
 
22178 
class getSettlementForCod_args:
22179 
  """
22180 
  Attributes:
22181 
   - orderId
22182 
   - isRefund
22183 
  """
22184 
 
22185 
  thrift_spec = (
22186 
    None, # 0
22187 
    (1, TType.I64, 'orderId', None, None, ), # 1
22188 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
22189 
  )
22190 
 
22191 
  def __init__(self, orderId=None, isRefund=None,):
22192 
    self.orderId = orderId
22193 
    self.isRefund = isRefund
22194 
 
22195 
  def read(self, iprot):
22196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22198 
      return
22199 
    iprot.readStructBegin()
22200 
    while True:
22201 
      (fname, ftype, fid) = iprot.readFieldBegin()
22202 
      if ftype == TType.STOP:
22203 
        break
22204 
      if fid == 1:
22205 
        if ftype == TType.I64:
22206 
          self.orderId = iprot.readI64();
22207 
        else:
22208 
          iprot.skip(ftype)
22209 
      elif fid == 2:
22210 
        if ftype == TType.BOOL:
22211 
          self.isRefund = iprot.readBool();
22212 
        else:
22213 
          iprot.skip(ftype)
22214 
      else:
22215 
        iprot.skip(ftype)
22216 
      iprot.readFieldEnd()
22217 
    iprot.readStructEnd()
22218 
 
22219 
  def write(self, oprot):
22220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22222 
      return
22223 
    oprot.writeStructBegin('getSettlementForCod_args')
22224 
    if self.orderId is not None:
22225 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22226 
      oprot.writeI64(self.orderId)
22227 
      oprot.writeFieldEnd()
5189 varun.gupt 22228 
    if self.isRefund is not None:
5386 phani.kuma 22229 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 22230 
      oprot.writeBool(self.isRefund)
22231 
      oprot.writeFieldEnd()
4600 varun.gupt 22232 
    oprot.writeFieldStop()
22233 
    oprot.writeStructEnd()
22234 
 
22235 
  def validate(self):
22236 
    return
22237 
 
22238 
 
22239 
  def __repr__(self):
22240 
    L = ['%s=%r' % (key, value)
22241 
      for key, value in self.__dict__.iteritems()]
22242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22243 
 
22244 
  def __eq__(self, other):
22245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22246 
 
22247 
  def __ne__(self, other):
22248 
    return not (self == other)
22249 
 
5386 phani.kuma 22250 
class getSettlementForCod_result:
4600 varun.gupt 22251 
  """
22252 
  Attributes:
22253 
   - success
22254 
   - ex
22255 
  """
22256 
 
22257 
  thrift_spec = (
22258 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22259 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22260 
  )
22261 
 
22262 
  def __init__(self, success=None, ex=None,):
22263 
    self.success = success
22264 
    self.ex = ex
22265 
 
22266 
  def read(self, iprot):
22267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22269 
      return
22270 
    iprot.readStructBegin()
22271 
    while True:
22272 
      (fname, ftype, fid) = iprot.readFieldBegin()
22273 
      if ftype == TType.STOP:
22274 
        break
22275 
      if fid == 0:
22276 
        if ftype == TType.STRUCT:
22277 
          self.success = PaymentSettlement()
22278 
          self.success.read(iprot)
22279 
        else:
22280 
          iprot.skip(ftype)
22281 
      elif fid == 1:
22282 
        if ftype == TType.STRUCT:
22283 
          self.ex = TransactionServiceException()
22284 
          self.ex.read(iprot)
22285 
        else:
22286 
          iprot.skip(ftype)
22287 
      else:
22288 
        iprot.skip(ftype)
22289 
      iprot.readFieldEnd()
22290 
    iprot.readStructEnd()
22291 
 
22292 
  def write(self, oprot):
22293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22295 
      return
5386 phani.kuma 22296 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 22297 
    if self.success is not None:
22298 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22299 
      self.success.write(oprot)
22300 
      oprot.writeFieldEnd()
22301 
    if self.ex is not None:
22302 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22303 
      self.ex.write(oprot)
22304 
      oprot.writeFieldEnd()
22305 
    oprot.writeFieldStop()
22306 
    oprot.writeStructEnd()
22307 
 
22308 
  def validate(self):
22309 
    return
22310 
 
22311 
 
22312 
  def __repr__(self):
22313 
    L = ['%s=%r' % (key, value)
22314 
      for key, value in self.__dict__.iteritems()]
22315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22316 
 
22317 
  def __eq__(self, other):
22318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22319 
 
22320 
  def __ne__(self, other):
22321 
    return not (self == other)
22322 
 
22323 
class getEBSSettlementSummaries_args:
22324 
 
22325 
  thrift_spec = (
22326 
  )
22327 
 
22328 
  def read(self, iprot):
22329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22331 
      return
22332 
    iprot.readStructBegin()
22333 
    while True:
22334 
      (fname, ftype, fid) = iprot.readFieldBegin()
22335 
      if ftype == TType.STOP:
22336 
        break
22337 
      else:
22338 
        iprot.skip(ftype)
22339 
      iprot.readFieldEnd()
22340 
    iprot.readStructEnd()
22341 
 
22342 
  def write(self, oprot):
22343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22345 
      return
22346 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
22347 
    oprot.writeFieldStop()
22348 
    oprot.writeStructEnd()
22349 
 
22350 
  def validate(self):
22351 
    return
22352 
 
22353 
 
22354 
  def __repr__(self):
22355 
    L = ['%s=%r' % (key, value)
22356 
      for key, value in self.__dict__.iteritems()]
22357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22358 
 
22359 
  def __eq__(self, other):
22360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22361 
 
22362 
  def __ne__(self, other):
22363 
    return not (self == other)
22364 
 
22365 
class getEBSSettlementSummaries_result:
22366 
  """
22367 
  Attributes:
22368 
   - success
22369 
   - ex
22370 
  """
22371 
 
22372 
  thrift_spec = (
22373 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
22374 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22375 
  )
22376 
 
22377 
  def __init__(self, success=None, ex=None,):
22378 
    self.success = success
22379 
    self.ex = ex
22380 
 
22381 
  def read(self, iprot):
22382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22384 
      return
22385 
    iprot.readStructBegin()
22386 
    while True:
22387 
      (fname, ftype, fid) = iprot.readFieldBegin()
22388 
      if ftype == TType.STOP:
22389 
        break
22390 
      if fid == 0:
22391 
        if ftype == TType.MAP:
22392 
          self.success = {}
5713 rajveer 22393 
          (_ktype512, _vtype513, _size511 ) = iprot.readMapBegin()
22394 
          for _i515 in xrange(_size511):
22395 
            _key516 = iprot.readI64();
22396 
            _val517 = iprot.readString();
22397 
            self.success[_key516] = _val517
4600 varun.gupt 22398 
          iprot.readMapEnd()
22399 
        else:
22400 
          iprot.skip(ftype)
22401 
      elif fid == 1:
22402 
        if ftype == TType.STRUCT:
22403 
          self.ex = TransactionServiceException()
22404 
          self.ex.read(iprot)
22405 
        else:
22406 
          iprot.skip(ftype)
22407 
      else:
22408 
        iprot.skip(ftype)
22409 
      iprot.readFieldEnd()
22410 
    iprot.readStructEnd()
22411 
 
22412 
  def write(self, oprot):
22413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22415 
      return
22416 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
22417 
    if self.success is not None:
22418 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22419 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
5713 rajveer 22420 
      for kiter518,viter519 in self.success.items():
22421 
        oprot.writeI64(kiter518)
22422 
        oprot.writeString(viter519)
4600 varun.gupt 22423 
      oprot.writeMapEnd()
22424 
      oprot.writeFieldEnd()
22425 
    if self.ex is not None:
22426 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22427 
      self.ex.write(oprot)
22428 
      oprot.writeFieldEnd()
22429 
    oprot.writeFieldStop()
22430 
    oprot.writeStructEnd()
22431 
 
22432 
  def validate(self):
22433 
    return
22434 
 
22435 
 
22436 
  def __repr__(self):
22437 
    L = ['%s=%r' % (key, value)
22438 
      for key, value in self.__dict__.iteritems()]
22439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22440 
 
22441 
  def __eq__(self, other):
22442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22443 
 
22444 
  def __ne__(self, other):
22445 
    return not (self == other)
22446 
 
22447 
class markEBSSettlementUploaded_args:
22448 
  """
22449 
  Attributes:
22450 
   - settlementId
22451 
  """
22452 
 
22453 
  thrift_spec = (
22454 
    None, # 0
22455 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22456 
  )
22457 
 
22458 
  def __init__(self, settlementId=None,):
22459 
    self.settlementId = settlementId
22460 
 
22461 
  def read(self, iprot):
22462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22464 
      return
22465 
    iprot.readStructBegin()
22466 
    while True:
22467 
      (fname, ftype, fid) = iprot.readFieldBegin()
22468 
      if ftype == TType.STOP:
22469 
        break
22470 
      if fid == 1:
22471 
        if ftype == TType.I64:
22472 
          self.settlementId = iprot.readI64();
22473 
        else:
22474 
          iprot.skip(ftype)
22475 
      else:
22476 
        iprot.skip(ftype)
22477 
      iprot.readFieldEnd()
22478 
    iprot.readStructEnd()
22479 
 
22480 
  def write(self, oprot):
22481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22483 
      return
22484 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
22485 
    if self.settlementId is not None:
22486 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22487 
      oprot.writeI64(self.settlementId)
22488 
      oprot.writeFieldEnd()
22489 
    oprot.writeFieldStop()
22490 
    oprot.writeStructEnd()
22491 
 
22492 
  def validate(self):
22493 
    return
22494 
 
22495 
 
22496 
  def __repr__(self):
22497 
    L = ['%s=%r' % (key, value)
22498 
      for key, value in self.__dict__.iteritems()]
22499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22500 
 
22501 
  def __eq__(self, other):
22502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22503 
 
22504 
  def __ne__(self, other):
22505 
    return not (self == other)
22506 
 
22507 
class markEBSSettlementUploaded_result:
22508 
  """
22509 
  Attributes:
22510 
   - ex
22511 
  """
22512 
 
22513 
  thrift_spec = (
22514 
    None, # 0
22515 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22516 
  )
22517 
 
22518 
  def __init__(self, ex=None,):
22519 
    self.ex = ex
22520 
 
22521 
  def read(self, iprot):
22522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22524 
      return
22525 
    iprot.readStructBegin()
22526 
    while True:
22527 
      (fname, ftype, fid) = iprot.readFieldBegin()
22528 
      if ftype == TType.STOP:
22529 
        break
22530 
      if fid == 1:
22531 
        if ftype == TType.STRUCT:
22532 
          self.ex = TransactionServiceException()
22533 
          self.ex.read(iprot)
22534 
        else:
22535 
          iprot.skip(ftype)
22536 
      else:
22537 
        iprot.skip(ftype)
22538 
      iprot.readFieldEnd()
22539 
    iprot.readStructEnd()
22540 
 
22541 
  def write(self, oprot):
22542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22544 
      return
22545 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
22546 
    if self.ex is not None:
22547 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22548 
      self.ex.write(oprot)
22549 
      oprot.writeFieldEnd()
22550 
    oprot.writeFieldStop()
22551 
    oprot.writeStructEnd()
22552 
 
22553 
  def validate(self):
22554 
    return
22555 
 
22556 
 
22557 
  def __repr__(self):
22558 
    L = ['%s=%r' % (key, value)
22559 
      for key, value in self.__dict__.iteritems()]
22560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22561 
 
22562 
  def __eq__(self, other):
22563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22564 
 
22565 
  def __ne__(self, other):
22566 
    return not (self == other)
22567 
 
22568 
class getEBSSettlementDate_args:
22569 
  """
22570 
  Attributes:
22571 
   - settlementId
22572 
  """
22573 
 
22574 
  thrift_spec = (
22575 
    None, # 0
22576 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22577 
  )
22578 
 
22579 
  def __init__(self, settlementId=None,):
22580 
    self.settlementId = settlementId
22581 
 
22582 
  def read(self, iprot):
22583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22585 
      return
22586 
    iprot.readStructBegin()
22587 
    while True:
22588 
      (fname, ftype, fid) = iprot.readFieldBegin()
22589 
      if ftype == TType.STOP:
22590 
        break
22591 
      if fid == 1:
22592 
        if ftype == TType.I64:
22593 
          self.settlementId = iprot.readI64();
22594 
        else:
22595 
          iprot.skip(ftype)
22596 
      else:
22597 
        iprot.skip(ftype)
22598 
      iprot.readFieldEnd()
22599 
    iprot.readStructEnd()
22600 
 
22601 
  def write(self, oprot):
22602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22604 
      return
22605 
    oprot.writeStructBegin('getEBSSettlementDate_args')
22606 
    if self.settlementId is not None:
22607 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22608 
      oprot.writeI64(self.settlementId)
22609 
      oprot.writeFieldEnd()
22610 
    oprot.writeFieldStop()
22611 
    oprot.writeStructEnd()
22612 
 
22613 
  def validate(self):
22614 
    return
22615 
 
22616 
 
22617 
  def __repr__(self):
22618 
    L = ['%s=%r' % (key, value)
22619 
      for key, value in self.__dict__.iteritems()]
22620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22621 
 
22622 
  def __eq__(self, other):
22623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22624 
 
22625 
  def __ne__(self, other):
22626 
    return not (self == other)
22627 
 
22628 
class getEBSSettlementDate_result:
22629 
  """
22630 
  Attributes:
22631 
   - success
22632 
   - ex
22633 
  """
22634 
 
22635 
  thrift_spec = (
22636 
    (0, TType.I64, 'success', None, None, ), # 0
22637 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22638 
  )
22639 
 
22640 
  def __init__(self, success=None, ex=None,):
22641 
    self.success = success
22642 
    self.ex = ex
22643 
 
22644 
  def read(self, iprot):
22645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22647 
      return
22648 
    iprot.readStructBegin()
22649 
    while True:
22650 
      (fname, ftype, fid) = iprot.readFieldBegin()
22651 
      if ftype == TType.STOP:
22652 
        break
22653 
      if fid == 0:
22654 
        if ftype == TType.I64:
22655 
          self.success = iprot.readI64();
22656 
        else:
22657 
          iprot.skip(ftype)
22658 
      elif fid == 1:
22659 
        if ftype == TType.STRUCT:
22660 
          self.ex = TransactionServiceException()
22661 
          self.ex.read(iprot)
22662 
        else:
22663 
          iprot.skip(ftype)
22664 
      else:
22665 
        iprot.skip(ftype)
22666 
      iprot.readFieldEnd()
22667 
    iprot.readStructEnd()
22668 
 
22669 
  def write(self, oprot):
22670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22672 
      return
22673 
    oprot.writeStructBegin('getEBSSettlementDate_result')
22674 
    if self.success is not None:
22675 
      oprot.writeFieldBegin('success', TType.I64, 0)
22676 
      oprot.writeI64(self.success)
22677 
      oprot.writeFieldEnd()
22678 
    if self.ex is not None:
22679 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22680 
      self.ex.write(oprot)
22681 
      oprot.writeFieldEnd()
22682 
    oprot.writeFieldStop()
22683 
    oprot.writeStructEnd()
22684 
 
22685 
  def validate(self):
22686 
    return
22687 
 
22688 
 
22689 
  def __repr__(self):
22690 
    L = ['%s=%r' % (key, value)
22691 
      for key, value in self.__dict__.iteritems()]
22692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22693 
 
22694 
  def __eq__(self, other):
22695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22696 
 
22697 
  def __ne__(self, other):
22698 
    return not (self == other)
4715 varun.gupt 22699 
 
22700 
class getSettlementsByDate_args:
22701 
  """
22702 
  Attributes:
22703 
   - settlementDateFrom
22704 
   - settlementDateTo
22705 
   - isRefund
22706 
  """
22707 
 
22708 
  thrift_spec = (
22709 
    None, # 0
22710 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
22711 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
22712 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
22713 
  )
22714 
 
22715 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
22716 
    self.settlementDateFrom = settlementDateFrom
22717 
    self.settlementDateTo = settlementDateTo
22718 
    self.isRefund = isRefund
22719 
 
22720 
  def read(self, iprot):
22721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22723 
      return
22724 
    iprot.readStructBegin()
22725 
    while True:
22726 
      (fname, ftype, fid) = iprot.readFieldBegin()
22727 
      if ftype == TType.STOP:
22728 
        break
22729 
      if fid == 1:
22730 
        if ftype == TType.I64:
22731 
          self.settlementDateFrom = iprot.readI64();
22732 
        else:
22733 
          iprot.skip(ftype)
22734 
      elif fid == 2:
22735 
        if ftype == TType.I64:
22736 
          self.settlementDateTo = iprot.readI64();
22737 
        else:
22738 
          iprot.skip(ftype)
22739 
      elif fid == 3:
22740 
        if ftype == TType.BOOL:
22741 
          self.isRefund = iprot.readBool();
22742 
        else:
22743 
          iprot.skip(ftype)
22744 
      else:
22745 
        iprot.skip(ftype)
22746 
      iprot.readFieldEnd()
22747 
    iprot.readStructEnd()
22748 
 
22749 
  def write(self, oprot):
22750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22752 
      return
22753 
    oprot.writeStructBegin('getSettlementsByDate_args')
22754 
    if self.settlementDateFrom is not None:
22755 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
22756 
      oprot.writeI64(self.settlementDateFrom)
22757 
      oprot.writeFieldEnd()
22758 
    if self.settlementDateTo is not None:
22759 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
22760 
      oprot.writeI64(self.settlementDateTo)
22761 
      oprot.writeFieldEnd()
22762 
    if self.isRefund is not None:
22763 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
22764 
      oprot.writeBool(self.isRefund)
22765 
      oprot.writeFieldEnd()
22766 
    oprot.writeFieldStop()
22767 
    oprot.writeStructEnd()
22768 
 
22769 
  def validate(self):
22770 
    return
22771 
 
22772 
 
22773 
  def __repr__(self):
22774 
    L = ['%s=%r' % (key, value)
22775 
      for key, value in self.__dict__.iteritems()]
22776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22777 
 
22778 
  def __eq__(self, other):
22779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22780 
 
22781 
  def __ne__(self, other):
22782 
    return not (self == other)
22783 
 
22784 
class getSettlementsByDate_result:
22785 
  """
22786 
  Attributes:
22787 
   - success
22788 
   - ex
22789 
  """
22790 
 
22791 
  thrift_spec = (
22792 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
22793 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22794 
  )
22795 
 
22796 
  def __init__(self, success=None, ex=None,):
22797 
    self.success = success
22798 
    self.ex = ex
22799 
 
22800 
  def read(self, iprot):
22801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22803 
      return
22804 
    iprot.readStructBegin()
22805 
    while True:
22806 
      (fname, ftype, fid) = iprot.readFieldBegin()
22807 
      if ftype == TType.STOP:
22808 
        break
22809 
      if fid == 0:
22810 
        if ftype == TType.LIST:
22811 
          self.success = []
5713 rajveer 22812 
          (_etype523, _size520) = iprot.readListBegin()
22813 
          for _i524 in xrange(_size520):
22814 
            _elem525 = PaymentSettlement()
22815 
            _elem525.read(iprot)
22816 
            self.success.append(_elem525)
4715 varun.gupt 22817 
          iprot.readListEnd()
22818 
        else:
22819 
          iprot.skip(ftype)
22820 
      elif fid == 1:
22821 
        if ftype == TType.STRUCT:
22822 
          self.ex = TransactionServiceException()
22823 
          self.ex.read(iprot)
22824 
        else:
22825 
          iprot.skip(ftype)
22826 
      else:
22827 
        iprot.skip(ftype)
22828 
      iprot.readFieldEnd()
22829 
    iprot.readStructEnd()
22830 
 
22831 
  def write(self, oprot):
22832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22834 
      return
22835 
    oprot.writeStructBegin('getSettlementsByDate_result')
22836 
    if self.success is not None:
22837 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22838 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 22839 
      for iter526 in self.success:
22840 
        iter526.write(oprot)
4715 varun.gupt 22841 
      oprot.writeListEnd()
22842 
      oprot.writeFieldEnd()
22843 
    if self.ex is not None:
22844 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22845 
      self.ex.write(oprot)
22846 
      oprot.writeFieldEnd()
22847 
    oprot.writeFieldStop()
22848 
    oprot.writeStructEnd()
22849 
 
22850 
  def validate(self):
22851 
    return
22852 
 
22853 
 
22854 
  def __repr__(self):
22855 
    L = ['%s=%r' % (key, value)
22856 
      for key, value in self.__dict__.iteritems()]
22857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22858 
 
22859 
  def __eq__(self, other):
22860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22861 
 
22862 
  def __ne__(self, other):
22863 
    return not (self == other)
22864 
 
22865 
class getReshippedOrderIds_args:
22866 
  """
22867 
  Attributes:
22868 
   - orderIds
22869 
  """
22870 
 
22871 
  thrift_spec = (
22872 
    None, # 0
22873 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
22874 
  )
22875 
 
22876 
  def __init__(self, orderIds=None,):
22877 
    self.orderIds = orderIds
22878 
 
22879 
  def read(self, iprot):
22880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22882 
      return
22883 
    iprot.readStructBegin()
22884 
    while True:
22885 
      (fname, ftype, fid) = iprot.readFieldBegin()
22886 
      if ftype == TType.STOP:
22887 
        break
22888 
      if fid == 1:
22889 
        if ftype == TType.LIST:
22890 
          self.orderIds = []
5713 rajveer 22891 
          (_etype530, _size527) = iprot.readListBegin()
22892 
          for _i531 in xrange(_size527):
22893 
            _elem532 = iprot.readI64();
22894 
            self.orderIds.append(_elem532)
4715 varun.gupt 22895 
          iprot.readListEnd()
22896 
        else:
22897 
          iprot.skip(ftype)
22898 
      else:
22899 
        iprot.skip(ftype)
22900 
      iprot.readFieldEnd()
22901 
    iprot.readStructEnd()
22902 
 
22903 
  def write(self, oprot):
22904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22906 
      return
22907 
    oprot.writeStructBegin('getReshippedOrderIds_args')
22908 
    if self.orderIds is not None:
22909 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
22910 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
5713 rajveer 22911 
      for iter533 in self.orderIds:
22912 
        oprot.writeI64(iter533)
4715 varun.gupt 22913 
      oprot.writeListEnd()
22914 
      oprot.writeFieldEnd()
22915 
    oprot.writeFieldStop()
22916 
    oprot.writeStructEnd()
22917 
 
22918 
  def validate(self):
22919 
    return
22920 
 
22921 
 
22922 
  def __repr__(self):
22923 
    L = ['%s=%r' % (key, value)
22924 
      for key, value in self.__dict__.iteritems()]
22925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22926 
 
22927 
  def __eq__(self, other):
22928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22929 
 
22930 
  def __ne__(self, other):
22931 
    return not (self == other)
22932 
 
22933 
class getReshippedOrderIds_result:
22934 
  """
22935 
  Attributes:
22936 
   - success
22937 
   - ex
22938 
  """
22939 
 
22940 
  thrift_spec = (
22941 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
22942 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22943 
  )
22944 
 
22945 
  def __init__(self, success=None, ex=None,):
22946 
    self.success = success
22947 
    self.ex = ex
22948 
 
22949 
  def read(self, iprot):
22950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22952 
      return
22953 
    iprot.readStructBegin()
22954 
    while True:
22955 
      (fname, ftype, fid) = iprot.readFieldBegin()
22956 
      if ftype == TType.STOP:
22957 
        break
22958 
      if fid == 0:
22959 
        if ftype == TType.LIST:
22960 
          self.success = []
5713 rajveer 22961 
          (_etype537, _size534) = iprot.readListBegin()
22962 
          for _i538 in xrange(_size534):
22963 
            _elem539 = iprot.readI64();
22964 
            self.success.append(_elem539)
4715 varun.gupt 22965 
          iprot.readListEnd()
22966 
        else:
22967 
          iprot.skip(ftype)
22968 
      elif fid == 1:
22969 
        if ftype == TType.STRUCT:
22970 
          self.ex = TransactionServiceException()
22971 
          self.ex.read(iprot)
22972 
        else:
22973 
          iprot.skip(ftype)
22974 
      else:
22975 
        iprot.skip(ftype)
22976 
      iprot.readFieldEnd()
22977 
    iprot.readStructEnd()
22978 
 
22979 
  def write(self, oprot):
22980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22982 
      return
22983 
    oprot.writeStructBegin('getReshippedOrderIds_result')
22984 
    if self.success is not None:
22985 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22986 
      oprot.writeListBegin(TType.I64, len(self.success))
5713 rajveer 22987 
      for iter540 in self.success:
22988 
        oprot.writeI64(iter540)
4715 varun.gupt 22989 
      oprot.writeListEnd()
22990 
      oprot.writeFieldEnd()
22991 
    if self.ex is not None:
22992 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22993 
      self.ex.write(oprot)
22994 
      oprot.writeFieldEnd()
22995 
    oprot.writeFieldStop()
22996 
    oprot.writeStructEnd()
22997 
 
22998 
  def validate(self):
22999 
    return
23000 
 
23001 
 
23002 
  def __repr__(self):
23003 
    L = ['%s=%r' % (key, value)
23004 
      for key, value in self.__dict__.iteritems()]
23005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23006 
 
23007 
  def __eq__(self, other):
23008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23009 
 
23010 
  def __ne__(self, other):
23011 
    return not (self == other)
4757 mandeep.dh 23012 
 
5481 phani.kuma 23013 
class getBilledOrders_args:
4875 varun.gupt 23014 
  """
23015 
  Attributes:
23016 
   - vendorId
5481 phani.kuma 23017 
   - onlyVendorNotPaid
23018 
   - billingDateFrom
23019 
   - billingDateTo
4875 varun.gupt 23020 
  """
23021 
 
23022 
  thrift_spec = (
23023 
    None, # 0
23024 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 23025 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
23026 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
23027 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 23028 
  )
23029 
 
5481 phani.kuma 23030 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 23031 
    self.vendorId = vendorId
5481 phani.kuma 23032 
    self.onlyVendorNotPaid = onlyVendorNotPaid
23033 
    self.billingDateFrom = billingDateFrom
23034 
    self.billingDateTo = billingDateTo
4875 varun.gupt 23035 
 
23036 
  def read(self, iprot):
23037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23039 
      return
23040 
    iprot.readStructBegin()
23041 
    while True:
23042 
      (fname, ftype, fid) = iprot.readFieldBegin()
23043 
      if ftype == TType.STOP:
23044 
        break
23045 
      if fid == 1:
23046 
        if ftype == TType.I64:
23047 
          self.vendorId = iprot.readI64();
23048 
        else:
23049 
          iprot.skip(ftype)
5481 phani.kuma 23050 
      elif fid == 2:
23051 
        if ftype == TType.BOOL:
23052 
          self.onlyVendorNotPaid = iprot.readBool();
23053 
        else:
23054 
          iprot.skip(ftype)
23055 
      elif fid == 3:
23056 
        if ftype == TType.I64:
23057 
          self.billingDateFrom = iprot.readI64();
23058 
        else:
23059 
          iprot.skip(ftype)
23060 
      elif fid == 4:
23061 
        if ftype == TType.I64:
23062 
          self.billingDateTo = iprot.readI64();
23063 
        else:
23064 
          iprot.skip(ftype)
4875 varun.gupt 23065 
      else:
23066 
        iprot.skip(ftype)
23067 
      iprot.readFieldEnd()
23068 
    iprot.readStructEnd()
23069 
 
23070 
  def write(self, oprot):
23071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23073 
      return
5481 phani.kuma 23074 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 23075 
    if self.vendorId is not None:
23076 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23077 
      oprot.writeI64(self.vendorId)
23078 
      oprot.writeFieldEnd()
5481 phani.kuma 23079 
    if self.onlyVendorNotPaid is not None:
23080 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
23081 
      oprot.writeBool(self.onlyVendorNotPaid)
23082 
      oprot.writeFieldEnd()
23083 
    if self.billingDateFrom is not None:
23084 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
23085 
      oprot.writeI64(self.billingDateFrom)
23086 
      oprot.writeFieldEnd()
23087 
    if self.billingDateTo is not None:
23088 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
23089 
      oprot.writeI64(self.billingDateTo)
23090 
      oprot.writeFieldEnd()
4875 varun.gupt 23091 
    oprot.writeFieldStop()
23092 
    oprot.writeStructEnd()
23093 
 
23094 
  def validate(self):
23095 
    return
23096 
 
23097 
 
23098 
  def __repr__(self):
23099 
    L = ['%s=%r' % (key, value)
23100 
      for key, value in self.__dict__.iteritems()]
23101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23102 
 
23103 
  def __eq__(self, other):
23104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23105 
 
23106 
  def __ne__(self, other):
23107 
    return not (self == other)
23108 
 
5481 phani.kuma 23109 
class getBilledOrders_result:
4875 varun.gupt 23110 
  """
23111 
  Attributes:
23112 
   - success
23113 
   - ex
23114 
  """
23115 
 
23116 
  thrift_spec = (
23117 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23118 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23119 
  )
23120 
 
23121 
  def __init__(self, success=None, ex=None,):
23122 
    self.success = success
23123 
    self.ex = ex
23124 
 
23125 
  def read(self, iprot):
23126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23128 
      return
23129 
    iprot.readStructBegin()
23130 
    while True:
23131 
      (fname, ftype, fid) = iprot.readFieldBegin()
23132 
      if ftype == TType.STOP:
23133 
        break
23134 
      if fid == 0:
23135 
        if ftype == TType.LIST:
23136 
          self.success = []
5713 rajveer 23137 
          (_etype544, _size541) = iprot.readListBegin()
23138 
          for _i545 in xrange(_size541):
23139 
            _elem546 = Order()
23140 
            _elem546.read(iprot)
23141 
            self.success.append(_elem546)
4875 varun.gupt 23142 
          iprot.readListEnd()
23143 
        else:
23144 
          iprot.skip(ftype)
23145 
      elif fid == 1:
23146 
        if ftype == TType.STRUCT:
23147 
          self.ex = TransactionServiceException()
23148 
          self.ex.read(iprot)
23149 
        else:
23150 
          iprot.skip(ftype)
23151 
      else:
23152 
        iprot.skip(ftype)
23153 
      iprot.readFieldEnd()
23154 
    iprot.readStructEnd()
23155 
 
23156 
  def write(self, oprot):
23157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23159 
      return
5481 phani.kuma 23160 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 23161 
    if self.success is not None:
23162 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23163 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 23164 
      for iter547 in self.success:
23165 
        iter547.write(oprot)
4875 varun.gupt 23166 
      oprot.writeListEnd()
23167 
      oprot.writeFieldEnd()
23168 
    if self.ex is not None:
23169 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23170 
      self.ex.write(oprot)
23171 
      oprot.writeFieldEnd()
23172 
    oprot.writeFieldStop()
23173 
    oprot.writeStructEnd()
23174 
 
23175 
  def validate(self):
23176 
    return
23177 
 
23178 
 
23179 
  def __repr__(self):
23180 
    L = ['%s=%r' % (key, value)
23181 
      for key, value in self.__dict__.iteritems()]
23182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23183 
 
23184 
  def __eq__(self, other):
23185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23186 
 
23187 
  def __ne__(self, other):
23188 
    return not (self == other)
5031 varun.gupt 23189 
 
23190 
class getStatusDistributionOfOrders_args:
23191 
  """
23192 
  Attributes:
23193 
   - startDate
23194 
   - endDate
23195 
  """
23196 
 
23197 
  thrift_spec = (
23198 
    None, # 0
23199 
    (1, TType.I64, 'startDate', None, None, ), # 1
23200 
    (2, TType.I64, 'endDate', None, None, ), # 2
23201 
  )
23202 
 
23203 
  def __init__(self, startDate=None, endDate=None,):
23204 
    self.startDate = startDate
23205 
    self.endDate = endDate
23206 
 
23207 
  def read(self, iprot):
23208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23210 
      return
23211 
    iprot.readStructBegin()
23212 
    while True:
23213 
      (fname, ftype, fid) = iprot.readFieldBegin()
23214 
      if ftype == TType.STOP:
23215 
        break
23216 
      if fid == 1:
23217 
        if ftype == TType.I64:
23218 
          self.startDate = iprot.readI64();
23219 
        else:
23220 
          iprot.skip(ftype)
23221 
      elif fid == 2:
23222 
        if ftype == TType.I64:
23223 
          self.endDate = iprot.readI64();
23224 
        else:
23225 
          iprot.skip(ftype)
23226 
      else:
23227 
        iprot.skip(ftype)
23228 
      iprot.readFieldEnd()
23229 
    iprot.readStructEnd()
23230 
 
23231 
  def write(self, oprot):
23232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23234 
      return
23235 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
23236 
    if self.startDate is not None:
23237 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
23238 
      oprot.writeI64(self.startDate)
23239 
      oprot.writeFieldEnd()
23240 
    if self.endDate is not None:
23241 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
23242 
      oprot.writeI64(self.endDate)
23243 
      oprot.writeFieldEnd()
23244 
    oprot.writeFieldStop()
23245 
    oprot.writeStructEnd()
23246 
 
23247 
  def validate(self):
23248 
    return
23249 
 
23250 
 
23251 
  def __repr__(self):
23252 
    L = ['%s=%r' % (key, value)
23253 
      for key, value in self.__dict__.iteritems()]
23254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23255 
 
23256 
  def __eq__(self, other):
23257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23258 
 
23259 
  def __ne__(self, other):
23260 
    return not (self == other)
23261 
 
23262 
class getStatusDistributionOfOrders_result:
23263 
  """
23264 
  Attributes:
23265 
   - success
23266 
   - ex
23267 
  """
23268 
 
23269 
  thrift_spec = (
23270 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
23271 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23272 
  )
23273 
 
23274 
  def __init__(self, success=None, ex=None,):
23275 
    self.success = success
23276 
    self.ex = ex
23277 
 
23278 
  def read(self, iprot):
23279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23281 
      return
23282 
    iprot.readStructBegin()
23283 
    while True:
23284 
      (fname, ftype, fid) = iprot.readFieldBegin()
23285 
      if ftype == TType.STOP:
23286 
        break
23287 
      if fid == 0:
23288 
        if ftype == TType.MAP:
23289 
          self.success = {}
5713 rajveer 23290 
          (_ktype549, _vtype550, _size548 ) = iprot.readMapBegin()
23291 
          for _i552 in xrange(_size548):
23292 
            _key553 = iprot.readI64();
23293 
            _val554 = iprot.readI64();
23294 
            self.success[_key553] = _val554
5031 varun.gupt 23295 
          iprot.readMapEnd()
23296 
        else:
23297 
          iprot.skip(ftype)
23298 
      elif fid == 1:
23299 
        if ftype == TType.STRUCT:
23300 
          self.ex = TransactionServiceException()
23301 
          self.ex.read(iprot)
23302 
        else:
23303 
          iprot.skip(ftype)
23304 
      else:
23305 
        iprot.skip(ftype)
23306 
      iprot.readFieldEnd()
23307 
    iprot.readStructEnd()
23308 
 
23309 
  def write(self, oprot):
23310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23312 
      return
23313 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
23314 
    if self.success is not None:
23315 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23316 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
5713 rajveer 23317 
      for kiter555,viter556 in self.success.items():
23318 
        oprot.writeI64(kiter555)
23319 
        oprot.writeI64(viter556)
5031 varun.gupt 23320 
      oprot.writeMapEnd()
23321 
      oprot.writeFieldEnd()
23322 
    if self.ex is not None:
23323 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23324 
      self.ex.write(oprot)
23325 
      oprot.writeFieldEnd()
23326 
    oprot.writeFieldStop()
23327 
    oprot.writeStructEnd()
23328 
 
23329 
  def validate(self):
23330 
    return
23331 
 
23332 
 
23333 
  def __repr__(self):
23334 
    L = ['%s=%r' % (key, value)
23335 
      for key, value in self.__dict__.iteritems()]
23336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23337 
 
23338 
  def __eq__(self, other):
23339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23340 
 
23341 
  def __ne__(self, other):
23342 
    return not (self == other)
5067 varun.gupt 23343 
 
23344 
class getOrderIdsForStatus_args:
23345 
  """
23346 
  Attributes:
23347 
   - status
23348 
   - startDatetime
23349 
   - endDatetime
23350 
  """
23351 
 
23352 
  thrift_spec = (
23353 
    None, # 0
23354 
    (1, TType.I64, 'status', None, None, ), # 1
23355 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
23356 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
23357 
  )
23358 
 
23359 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
23360 
    self.status = status
23361 
    self.startDatetime = startDatetime
23362 
    self.endDatetime = endDatetime
23363 
 
23364 
  def read(self, iprot):
23365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23367 
      return
23368 
    iprot.readStructBegin()
23369 
    while True:
23370 
      (fname, ftype, fid) = iprot.readFieldBegin()
23371 
      if ftype == TType.STOP:
23372 
        break
23373 
      if fid == 1:
23374 
        if ftype == TType.I64:
23375 
          self.status = iprot.readI64();
23376 
        else:
23377 
          iprot.skip(ftype)
23378 
      elif fid == 2:
23379 
        if ftype == TType.I64:
23380 
          self.startDatetime = iprot.readI64();
23381 
        else:
23382 
          iprot.skip(ftype)
23383 
      elif fid == 3:
23384 
        if ftype == TType.I64:
23385 
          self.endDatetime = iprot.readI64();
23386 
        else:
23387 
          iprot.skip(ftype)
23388 
      else:
23389 
        iprot.skip(ftype)
23390 
      iprot.readFieldEnd()
23391 
    iprot.readStructEnd()
23392 
 
23393 
  def write(self, oprot):
23394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23396 
      return
23397 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
23398 
    if self.status is not None:
23399 
      oprot.writeFieldBegin('status', TType.I64, 1)
23400 
      oprot.writeI64(self.status)
23401 
      oprot.writeFieldEnd()
23402 
    if self.startDatetime is not None:
23403 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
23404 
      oprot.writeI64(self.startDatetime)
23405 
      oprot.writeFieldEnd()
23406 
    if self.endDatetime is not None:
23407 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
23408 
      oprot.writeI64(self.endDatetime)
23409 
      oprot.writeFieldEnd()
23410 
    oprot.writeFieldStop()
23411 
    oprot.writeStructEnd()
23412 
 
23413 
  def validate(self):
23414 
    return
23415 
 
23416 
 
23417 
  def __repr__(self):
23418 
    L = ['%s=%r' % (key, value)
23419 
      for key, value in self.__dict__.iteritems()]
23420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23421 
 
23422 
  def __eq__(self, other):
23423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23424 
 
23425 
  def __ne__(self, other):
23426 
    return not (self == other)
23427 
 
23428 
class getOrderIdsForStatus_result:
23429 
  """
23430 
  Attributes:
23431 
   - success
23432 
   - ex
23433 
  """
23434 
 
23435 
  thrift_spec = (
23436 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23437 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23438 
  )
23439 
 
23440 
  def __init__(self, success=None, ex=None,):
23441 
    self.success = success
23442 
    self.ex = ex
23443 
 
23444 
  def read(self, iprot):
23445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23447 
      return
23448 
    iprot.readStructBegin()
23449 
    while True:
23450 
      (fname, ftype, fid) = iprot.readFieldBegin()
23451 
      if ftype == TType.STOP:
23452 
        break
23453 
      if fid == 0:
23454 
        if ftype == TType.LIST:
23455 
          self.success = []
5713 rajveer 23456 
          (_etype560, _size557) = iprot.readListBegin()
23457 
          for _i561 in xrange(_size557):
23458 
            _elem562 = iprot.readI64();
23459 
            self.success.append(_elem562)
5067 varun.gupt 23460 
          iprot.readListEnd()
23461 
        else:
23462 
          iprot.skip(ftype)
23463 
      elif fid == 1:
23464 
        if ftype == TType.STRUCT:
23465 
          self.ex = TransactionServiceException()
23466 
          self.ex.read(iprot)
23467 
        else:
23468 
          iprot.skip(ftype)
23469 
      else:
23470 
        iprot.skip(ftype)
23471 
      iprot.readFieldEnd()
23472 
    iprot.readStructEnd()
23473 
 
23474 
  def write(self, oprot):
23475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23477 
      return
23478 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
23479 
    if self.success is not None:
23480 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23481 
      oprot.writeListBegin(TType.I64, len(self.success))
5713 rajveer 23482 
      for iter563 in self.success:
23483 
        oprot.writeI64(iter563)
5067 varun.gupt 23484 
      oprot.writeListEnd()
23485 
      oprot.writeFieldEnd()
23486 
    if self.ex is not None:
23487 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23488 
      self.ex.write(oprot)
23489 
      oprot.writeFieldEnd()
23490 
    oprot.writeFieldStop()
23491 
    oprot.writeStructEnd()
23492 
 
23493 
  def validate(self):
23494 
    return
23495 
 
23496 
 
23497 
  def __repr__(self):
23498 
    L = ['%s=%r' % (key, value)
23499 
      for key, value in self.__dict__.iteritems()]
23500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23501 
 
23502 
  def __eq__(self, other):
23503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23504 
 
23505 
  def __ne__(self, other):
23506 
    return not (self == other)
5099 varun.gupt 23507 
 
5348 anupam.sin 23508 
class updateCODAgent_args:
23509 
  """
23510 
  Attributes:
23511 
   - agent
23512 
   - orderId
23513 
  """
23514 
 
23515 
  thrift_spec = (
23516 
    None, # 0
23517 
    (1, TType.STRING, 'agent', None, None, ), # 1
23518 
    (2, TType.I64, 'orderId', None, None, ), # 2
23519 
  )
23520 
 
23521 
  def __init__(self, agent=None, orderId=None,):
23522 
    self.agent = agent
23523 
    self.orderId = orderId
23524 
 
23525 
  def read(self, iprot):
23526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23528 
      return
23529 
    iprot.readStructBegin()
23530 
    while True:
23531 
      (fname, ftype, fid) = iprot.readFieldBegin()
23532 
      if ftype == TType.STOP:
23533 
        break
23534 
      if fid == 1:
23535 
        if ftype == TType.STRING:
23536 
          self.agent = iprot.readString();
23537 
        else:
23538 
          iprot.skip(ftype)
23539 
      elif fid == 2:
23540 
        if ftype == TType.I64:
23541 
          self.orderId = iprot.readI64();
23542 
        else:
23543 
          iprot.skip(ftype)
23544 
      else:
23545 
        iprot.skip(ftype)
23546 
      iprot.readFieldEnd()
23547 
    iprot.readStructEnd()
23548 
 
23549 
  def write(self, oprot):
23550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23552 
      return
23553 
    oprot.writeStructBegin('updateCODAgent_args')
23554 
    if self.agent is not None:
23555 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
23556 
      oprot.writeString(self.agent)
23557 
      oprot.writeFieldEnd()
23558 
    if self.orderId is not None:
23559 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
23560 
      oprot.writeI64(self.orderId)
23561 
      oprot.writeFieldEnd()
23562 
    oprot.writeFieldStop()
23563 
    oprot.writeStructEnd()
23564 
 
23565 
  def validate(self):
23566 
    return
23567 
 
23568 
 
23569 
  def __repr__(self):
23570 
    L = ['%s=%r' % (key, value)
23571 
      for key, value in self.__dict__.iteritems()]
23572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23573 
 
23574 
  def __eq__(self, other):
23575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23576 
 
23577 
  def __ne__(self, other):
23578 
    return not (self == other)
23579 
 
23580 
class updateCODAgent_result:
23581 
  """
23582 
  Attributes:
23583 
   - ex
23584 
  """
23585 
 
23586 
  thrift_spec = (
23587 
    None, # 0
23588 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23589 
  )
23590 
 
23591 
  def __init__(self, ex=None,):
23592 
    self.ex = ex
23593 
 
23594 
  def read(self, iprot):
23595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23597 
      return
23598 
    iprot.readStructBegin()
23599 
    while True:
23600 
      (fname, ftype, fid) = iprot.readFieldBegin()
23601 
      if ftype == TType.STOP:
23602 
        break
23603 
      if fid == 1:
23604 
        if ftype == TType.STRUCT:
23605 
          self.ex = TransactionServiceException()
23606 
          self.ex.read(iprot)
23607 
        else:
23608 
          iprot.skip(ftype)
23609 
      else:
23610 
        iprot.skip(ftype)
23611 
      iprot.readFieldEnd()
23612 
    iprot.readStructEnd()
23613 
 
23614 
  def write(self, oprot):
23615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23617 
      return
23618 
    oprot.writeStructBegin('updateCODAgent_result')
23619 
    if self.ex is not None:
23620 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23621 
      self.ex.write(oprot)
23622 
      oprot.writeFieldEnd()
23623 
    oprot.writeFieldStop()
23624 
    oprot.writeStructEnd()
23625 
 
23626 
  def validate(self):
23627 
    return
23628 
 
23629 
 
23630 
  def __repr__(self):
23631 
    L = ['%s=%r' % (key, value)
23632 
      for key, value in self.__dict__.iteritems()]
23633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23634 
 
23635 
  def __eq__(self, other):
23636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23637 
 
23638 
  def __ne__(self, other):
23639 
    return not (self == other)
23640 
 
5099 varun.gupt 23641 
class updateOrderAsPaidToVendor_args:
23642 
  """
23643 
  Attributes:
23644 
   - orderId
23645 
  """
23646 
 
23647 
  thrift_spec = (
23648 
    None, # 0
23649 
    (1, TType.I64, 'orderId', None, None, ), # 1
23650 
  )
23651 
 
23652 
  def __init__(self, orderId=None,):
23653 
    self.orderId = orderId
23654 
 
23655 
  def read(self, iprot):
23656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23658 
      return
23659 
    iprot.readStructBegin()
23660 
    while True:
23661 
      (fname, ftype, fid) = iprot.readFieldBegin()
23662 
      if ftype == TType.STOP:
23663 
        break
23664 
      if fid == 1:
23665 
        if ftype == TType.I64:
23666 
          self.orderId = iprot.readI64();
23667 
        else:
23668 
          iprot.skip(ftype)
23669 
      else:
23670 
        iprot.skip(ftype)
23671 
      iprot.readFieldEnd()
23672 
    iprot.readStructEnd()
23673 
 
23674 
  def write(self, oprot):
23675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23677 
      return
23678 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
23679 
    if self.orderId is not None:
23680 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23681 
      oprot.writeI64(self.orderId)
23682 
      oprot.writeFieldEnd()
23683 
    oprot.writeFieldStop()
23684 
    oprot.writeStructEnd()
23685 
 
23686 
  def validate(self):
23687 
    return
23688 
 
23689 
 
23690 
  def __repr__(self):
23691 
    L = ['%s=%r' % (key, value)
23692 
      for key, value in self.__dict__.iteritems()]
23693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23694 
 
23695 
  def __eq__(self, other):
23696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23697 
 
23698 
  def __ne__(self, other):
23699 
    return not (self == other)
23700 
 
23701 
class updateOrderAsPaidToVendor_result:
23702 
  """
23703 
  Attributes:
23704 
   - ex
23705 
  """
23706 
 
23707 
  thrift_spec = (
23708 
    None, # 0
23709 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23710 
  )
23711 
 
23712 
  def __init__(self, ex=None,):
23713 
    self.ex = ex
23714 
 
23715 
  def read(self, iprot):
23716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23718 
      return
23719 
    iprot.readStructBegin()
23720 
    while True:
23721 
      (fname, ftype, fid) = iprot.readFieldBegin()
23722 
      if ftype == TType.STOP:
23723 
        break
23724 
      if fid == 1:
23725 
        if ftype == TType.STRUCT:
23726 
          self.ex = TransactionServiceException()
23727 
          self.ex.read(iprot)
23728 
        else:
23729 
          iprot.skip(ftype)
23730 
      else:
23731 
        iprot.skip(ftype)
23732 
      iprot.readFieldEnd()
23733 
    iprot.readStructEnd()
23734 
 
23735 
  def write(self, oprot):
23736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23738 
      return
23739 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
23740 
    if self.ex is not None:
23741 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23742 
      self.ex.write(oprot)
23743 
      oprot.writeFieldEnd()
23744 
    oprot.writeFieldStop()
23745 
    oprot.writeStructEnd()
23746 
 
23747 
  def validate(self):
23748 
    return
23749 
 
23750 
 
23751 
  def __repr__(self):
23752 
    L = ['%s=%r' % (key, value)
23753 
      for key, value in self.__dict__.iteritems()]
23754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23755 
 
23756 
  def __eq__(self, other):
23757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23758 
 
23759 
  def __ne__(self, other):
23760 
    return not (self == other)
5208 varun.gupt 23761 
 
5386 phani.kuma 23762 
class updateOrderOnlyAsPaidToVendor_args:
23763 
  """
23764 
  Attributes:
23765 
   - orderId
23766 
  """
23767 
 
23768 
  thrift_spec = (
23769 
    None, # 0
23770 
    (1, TType.I64, 'orderId', None, None, ), # 1
23771 
  )
23772 
 
23773 
  def __init__(self, orderId=None,):
23774 
    self.orderId = orderId
23775 
 
23776 
  def read(self, iprot):
23777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23779 
      return
23780 
    iprot.readStructBegin()
23781 
    while True:
23782 
      (fname, ftype, fid) = iprot.readFieldBegin()
23783 
      if ftype == TType.STOP:
23784 
        break
23785 
      if fid == 1:
23786 
        if ftype == TType.I64:
23787 
          self.orderId = iprot.readI64();
23788 
        else:
23789 
          iprot.skip(ftype)
23790 
      else:
23791 
        iprot.skip(ftype)
23792 
      iprot.readFieldEnd()
23793 
    iprot.readStructEnd()
23794 
 
23795 
  def write(self, oprot):
23796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23798 
      return
23799 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
23800 
    if self.orderId is not None:
23801 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23802 
      oprot.writeI64(self.orderId)
23803 
      oprot.writeFieldEnd()
23804 
    oprot.writeFieldStop()
23805 
    oprot.writeStructEnd()
23806 
 
23807 
  def validate(self):
23808 
    return
23809 
 
23810 
 
23811 
  def __repr__(self):
23812 
    L = ['%s=%r' % (key, value)
23813 
      for key, value in self.__dict__.iteritems()]
23814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23815 
 
23816 
  def __eq__(self, other):
23817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23818 
 
23819 
  def __ne__(self, other):
23820 
    return not (self == other)
23821 
 
23822 
class updateOrderOnlyAsPaidToVendor_result:
23823 
  """
23824 
  Attributes:
23825 
   - ex
23826 
  """
23827 
 
23828 
  thrift_spec = (
23829 
    None, # 0
23830 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23831 
  )
23832 
 
23833 
  def __init__(self, ex=None,):
23834 
    self.ex = ex
23835 
 
23836 
  def read(self, iprot):
23837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23839 
      return
23840 
    iprot.readStructBegin()
23841 
    while True:
23842 
      (fname, ftype, fid) = iprot.readFieldBegin()
23843 
      if ftype == TType.STOP:
23844 
        break
23845 
      if fid == 1:
23846 
        if ftype == TType.STRUCT:
23847 
          self.ex = TransactionServiceException()
23848 
          self.ex.read(iprot)
23849 
        else:
23850 
          iprot.skip(ftype)
23851 
      else:
23852 
        iprot.skip(ftype)
23853 
      iprot.readFieldEnd()
23854 
    iprot.readStructEnd()
23855 
 
23856 
  def write(self, oprot):
23857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23859 
      return
23860 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
23861 
    if self.ex is not None:
23862 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23863 
      self.ex.write(oprot)
23864 
      oprot.writeFieldEnd()
23865 
    oprot.writeFieldStop()
23866 
    oprot.writeStructEnd()
23867 
 
23868 
  def validate(self):
23869 
    return
23870 
 
23871 
 
23872 
  def __repr__(self):
23873 
    L = ['%s=%r' % (key, value)
23874 
      for key, value in self.__dict__.iteritems()]
23875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23876 
 
23877 
  def __eq__(self, other):
23878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23879 
 
23880 
  def __ne__(self, other):
23881 
    return not (self == other)
23882 
 
5208 varun.gupt 23883 
class getRefundedOrdersMarkedPaid_args:
23884 
 
23885 
  thrift_spec = (
23886 
  )
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 
      else:
23898 
        iprot.skip(ftype)
23899 
      iprot.readFieldEnd()
23900 
    iprot.readStructEnd()
23901 
 
23902 
  def write(self, oprot):
23903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23905 
      return
23906 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
23907 
    oprot.writeFieldStop()
23908 
    oprot.writeStructEnd()
23909 
 
23910 
  def validate(self):
23911 
    return
23912 
 
23913 
 
23914 
  def __repr__(self):
23915 
    L = ['%s=%r' % (key, value)
23916 
      for key, value in self.__dict__.iteritems()]
23917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23918 
 
23919 
  def __eq__(self, other):
23920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23921 
 
23922 
  def __ne__(self, other):
23923 
    return not (self == other)
23924 
 
23925 
class getRefundedOrdersMarkedPaid_result:
23926 
  """
23927 
  Attributes:
23928 
   - success
23929 
   - ex
23930 
  """
23931 
 
23932 
  thrift_spec = (
23933 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23934 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23935 
  )
23936 
 
23937 
  def __init__(self, success=None, ex=None,):
23938 
    self.success = success
23939 
    self.ex = ex
23940 
 
23941 
  def read(self, iprot):
23942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23944 
      return
23945 
    iprot.readStructBegin()
23946 
    while True:
23947 
      (fname, ftype, fid) = iprot.readFieldBegin()
23948 
      if ftype == TType.STOP:
23949 
        break
23950 
      if fid == 0:
23951 
        if ftype == TType.LIST:
23952 
          self.success = []
5713 rajveer 23953 
          (_etype567, _size564) = iprot.readListBegin()
23954 
          for _i568 in xrange(_size564):
23955 
            _elem569 = Order()
23956 
            _elem569.read(iprot)
23957 
            self.success.append(_elem569)
5208 varun.gupt 23958 
          iprot.readListEnd()
23959 
        else:
23960 
          iprot.skip(ftype)
23961 
      elif fid == 1:
23962 
        if ftype == TType.STRUCT:
23963 
          self.ex = TransactionServiceException()
23964 
          self.ex.read(iprot)
23965 
        else:
23966 
          iprot.skip(ftype)
23967 
      else:
23968 
        iprot.skip(ftype)
23969 
      iprot.readFieldEnd()
23970 
    iprot.readStructEnd()
23971 
 
23972 
  def write(self, oprot):
23973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23975 
      return
23976 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
23977 
    if self.success is not None:
23978 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23979 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 23980 
      for iter570 in self.success:
23981 
        iter570.write(oprot)
5208 varun.gupt 23982 
      oprot.writeListEnd()
23983 
      oprot.writeFieldEnd()
23984 
    if self.ex is not None:
23985 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23986 
      self.ex.write(oprot)
23987 
      oprot.writeFieldEnd()
23988 
    oprot.writeFieldStop()
23989 
    oprot.writeStructEnd()
23990 
 
23991 
  def validate(self):
23992 
    return
23993 
 
23994 
 
23995 
  def __repr__(self):
23996 
    L = ['%s=%r' % (key, value)
23997 
      for key, value in self.__dict__.iteritems()]
23998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23999 
 
24000 
  def __eq__(self, other):
24001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24002 
 
24003 
  def __ne__(self, other):
24004 
    return not (self == other)
5447 anupam.sin 24005 
 
24006 
class getAllVerificationAgents_args:
24007 
  """
24008 
  Attributes:
24009 
   - minOrderId
24010 
   - maxOrderId
24011 
  """
24012 
 
24013 
  thrift_spec = (
24014 
    None, # 0
24015 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
24016 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
24017 
  )
24018 
 
24019 
  def __init__(self, minOrderId=None, maxOrderId=None,):
24020 
    self.minOrderId = minOrderId
24021 
    self.maxOrderId = maxOrderId
24022 
 
24023 
  def read(self, iprot):
24024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24026 
      return
24027 
    iprot.readStructBegin()
24028 
    while True:
24029 
      (fname, ftype, fid) = iprot.readFieldBegin()
24030 
      if ftype == TType.STOP:
24031 
        break
24032 
      if fid == 1:
24033 
        if ftype == TType.I64:
24034 
          self.minOrderId = iprot.readI64();
24035 
        else:
24036 
          iprot.skip(ftype)
24037 
      elif fid == 2:
24038 
        if ftype == TType.I64:
24039 
          self.maxOrderId = iprot.readI64();
24040 
        else:
24041 
          iprot.skip(ftype)
24042 
      else:
24043 
        iprot.skip(ftype)
24044 
      iprot.readFieldEnd()
24045 
    iprot.readStructEnd()
24046 
 
24047 
  def write(self, oprot):
24048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24050 
      return
24051 
    oprot.writeStructBegin('getAllVerificationAgents_args')
24052 
    if self.minOrderId is not None:
24053 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
24054 
      oprot.writeI64(self.minOrderId)
24055 
      oprot.writeFieldEnd()
24056 
    if self.maxOrderId is not None:
24057 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
24058 
      oprot.writeI64(self.maxOrderId)
24059 
      oprot.writeFieldEnd()
24060 
    oprot.writeFieldStop()
24061 
    oprot.writeStructEnd()
24062 
 
24063 
  def validate(self):
24064 
    return
24065 
 
24066 
 
24067 
  def __repr__(self):
24068 
    L = ['%s=%r' % (key, value)
24069 
      for key, value in self.__dict__.iteritems()]
24070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24071 
 
24072 
  def __eq__(self, other):
24073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24074 
 
24075 
  def __ne__(self, other):
24076 
    return not (self == other)
24077 
 
24078 
class getAllVerificationAgents_result:
24079 
  """
24080 
  Attributes:
24081 
   - success
24082 
  """
24083 
 
24084 
  thrift_spec = (
24085 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
24086 
  )
24087 
 
24088 
  def __init__(self, success=None,):
24089 
    self.success = success
24090 
 
24091 
  def read(self, iprot):
24092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24094 
      return
24095 
    iprot.readStructBegin()
24096 
    while True:
24097 
      (fname, ftype, fid) = iprot.readFieldBegin()
24098 
      if ftype == TType.STOP:
24099 
        break
24100 
      if fid == 0:
24101 
        if ftype == TType.LIST:
24102 
          self.success = []
5713 rajveer 24103 
          (_etype574, _size571) = iprot.readListBegin()
24104 
          for _i575 in xrange(_size571):
24105 
            _elem576 = CODVerificationAgent()
24106 
            _elem576.read(iprot)
24107 
            self.success.append(_elem576)
5447 anupam.sin 24108 
          iprot.readListEnd()
24109 
        else:
24110 
          iprot.skip(ftype)
24111 
      else:
24112 
        iprot.skip(ftype)
24113 
      iprot.readFieldEnd()
24114 
    iprot.readStructEnd()
24115 
 
24116 
  def write(self, oprot):
24117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24119 
      return
24120 
    oprot.writeStructBegin('getAllVerificationAgents_result')
24121 
    if self.success is not None:
24122 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24123 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 24124 
      for iter577 in self.success:
24125 
        iter577.write(oprot)
5447 anupam.sin 24126 
      oprot.writeListEnd()
24127 
      oprot.writeFieldEnd()
24128 
    oprot.writeFieldStop()
24129 
    oprot.writeStructEnd()
24130 
 
24131 
  def validate(self):
24132 
    return
24133 
 
24134 
 
24135 
  def __repr__(self):
24136 
    L = ['%s=%r' % (key, value)
24137 
      for key, value in self.__dict__.iteritems()]
24138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24139 
 
24140 
  def __eq__(self, other):
24141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24142 
 
24143 
  def __ne__(self, other):
24144 
    return not (self == other)
5527 anupam.sin 24145 
 
24146 
class getAllAttributesForOrderId_args:
24147 
  """
24148 
  Attributes:
24149 
   - orderId
24150 
  """
24151 
 
24152 
  thrift_spec = (
24153 
    None, # 0
24154 
    (1, TType.I64, 'orderId', None, None, ), # 1
24155 
  )
24156 
 
24157 
  def __init__(self, orderId=None,):
24158 
    self.orderId = orderId
24159 
 
24160 
  def read(self, iprot):
24161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24163 
      return
24164 
    iprot.readStructBegin()
24165 
    while True:
24166 
      (fname, ftype, fid) = iprot.readFieldBegin()
24167 
      if ftype == TType.STOP:
24168 
        break
24169 
      if fid == 1:
24170 
        if ftype == TType.I64:
24171 
          self.orderId = iprot.readI64();
24172 
        else:
24173 
          iprot.skip(ftype)
24174 
      else:
24175 
        iprot.skip(ftype)
24176 
      iprot.readFieldEnd()
24177 
    iprot.readStructEnd()
24178 
 
24179 
  def write(self, oprot):
24180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24182 
      return
24183 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
24184 
    if self.orderId is not None:
24185 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24186 
      oprot.writeI64(self.orderId)
24187 
      oprot.writeFieldEnd()
24188 
    oprot.writeFieldStop()
24189 
    oprot.writeStructEnd()
24190 
 
24191 
  def validate(self):
24192 
    return
24193 
 
24194 
 
24195 
  def __repr__(self):
24196 
    L = ['%s=%r' % (key, value)
24197 
      for key, value in self.__dict__.iteritems()]
24198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24199 
 
24200 
  def __eq__(self, other):
24201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24202 
 
24203 
  def __ne__(self, other):
24204 
    return not (self == other)
24205 
 
24206 
class getAllAttributesForOrderId_result:
24207 
  """
24208 
  Attributes:
24209 
   - success
24210 
  """
24211 
 
24212 
  thrift_spec = (
24213 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
24214 
  )
24215 
 
24216 
  def __init__(self, success=None,):
24217 
    self.success = success
24218 
 
24219 
  def read(self, iprot):
24220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24222 
      return
24223 
    iprot.readStructBegin()
24224 
    while True:
24225 
      (fname, ftype, fid) = iprot.readFieldBegin()
24226 
      if ftype == TType.STOP:
24227 
        break
24228 
      if fid == 0:
24229 
        if ftype == TType.LIST:
24230 
          self.success = []
5713 rajveer 24231 
          (_etype581, _size578) = iprot.readListBegin()
24232 
          for _i582 in xrange(_size578):
24233 
            _elem583 = Attribute()
24234 
            _elem583.read(iprot)
24235 
            self.success.append(_elem583)
5527 anupam.sin 24236 
          iprot.readListEnd()
24237 
        else:
24238 
          iprot.skip(ftype)
24239 
      else:
24240 
        iprot.skip(ftype)
24241 
      iprot.readFieldEnd()
24242 
    iprot.readStructEnd()
24243 
 
24244 
  def write(self, oprot):
24245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24247 
      return
24248 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
24249 
    if self.success is not None:
24250 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24251 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 24252 
      for iter584 in self.success:
24253 
        iter584.write(oprot)
5527 anupam.sin 24254 
      oprot.writeListEnd()
24255 
      oprot.writeFieldEnd()
24256 
    oprot.writeFieldStop()
24257 
    oprot.writeStructEnd()
24258 
 
24259 
  def validate(self):
24260 
    return
24261 
 
24262 
 
24263 
  def __repr__(self):
24264 
    L = ['%s=%r' % (key, value)
24265 
      for key, value in self.__dict__.iteritems()]
24266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24267 
 
24268 
  def __eq__(self, other):
24269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24270 
 
24271 
  def __ne__(self, other):
24272 
    return not (self == other)
24273 
 
5676 rajveer 24274 
class setOrderAttributes_args:
24275 
  """
24276 
  Attributes:
24277 
   - orderId
24278 
   - attributes
24279 
  """
24280 
 
24281 
  thrift_spec = None
24282 
  def __init__(self, orderId=None, attributes=None,):
24283 
    self.orderId = orderId
24284 
    self.attributes = attributes
24285 
 
24286 
  def read(self, iprot):
24287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24289 
      return
24290 
    iprot.readStructBegin()
24291 
    while True:
24292 
      (fname, ftype, fid) = iprot.readFieldBegin()
24293 
      if ftype == TType.STOP:
24294 
        break
24295 
      if fid == 1:
24296 
        if ftype == TType.I64:
24297 
          self.orderId = iprot.readI64();
24298 
        else:
24299 
          iprot.skip(ftype)
24300 
      elif fid == -1:
24301 
        if ftype == TType.LIST:
24302 
          self.attributes = []
5713 rajveer 24303 
          (_etype588, _size585) = iprot.readListBegin()
24304 
          for _i589 in xrange(_size585):
24305 
            _elem590 = Attribute()
24306 
            _elem590.read(iprot)
24307 
            self.attributes.append(_elem590)
5676 rajveer 24308 
          iprot.readListEnd()
24309 
        else:
24310 
          iprot.skip(ftype)
24311 
      else:
24312 
        iprot.skip(ftype)
24313 
      iprot.readFieldEnd()
24314 
    iprot.readStructEnd()
24315 
 
24316 
  def write(self, oprot):
24317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24319 
      return
24320 
    oprot.writeStructBegin('setOrderAttributes_args')
24321 
    if self.attributes is not None:
24322 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
24323 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
5713 rajveer 24324 
      for iter591 in self.attributes:
24325 
        iter591.write(oprot)
5676 rajveer 24326 
      oprot.writeListEnd()
24327 
      oprot.writeFieldEnd()
24328 
    if self.orderId is not None:
24329 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24330 
      oprot.writeI64(self.orderId)
24331 
      oprot.writeFieldEnd()
24332 
    oprot.writeFieldStop()
24333 
    oprot.writeStructEnd()
24334 
 
24335 
  def validate(self):
24336 
    return
24337 
 
24338 
 
24339 
  def __repr__(self):
24340 
    L = ['%s=%r' % (key, value)
24341 
      for key, value in self.__dict__.iteritems()]
24342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24343 
 
24344 
  def __eq__(self, other):
24345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24346 
 
24347 
  def __ne__(self, other):
24348 
    return not (self == other)
24349 
 
24350 
class setOrderAttributes_result:
24351 
 
24352 
  thrift_spec = (
24353 
  )
24354 
 
24355 
  def read(self, iprot):
24356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24358 
      return
24359 
    iprot.readStructBegin()
24360 
    while True:
24361 
      (fname, ftype, fid) = iprot.readFieldBegin()
24362 
      if ftype == TType.STOP:
24363 
        break
24364 
      else:
24365 
        iprot.skip(ftype)
24366 
      iprot.readFieldEnd()
24367 
    iprot.readStructEnd()
24368 
 
24369 
  def write(self, oprot):
24370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24372 
      return
24373 
    oprot.writeStructBegin('setOrderAttributes_result')
24374 
    oprot.writeFieldStop()
24375 
    oprot.writeStructEnd()
24376 
 
24377 
  def validate(self):
24378 
    return
24379 
 
24380 
 
24381 
  def __repr__(self):
24382 
    L = ['%s=%r' % (key, value)
24383 
      for key, value in self.__dict__.iteritems()]
24384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24385 
 
24386 
  def __eq__(self, other):
24387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24388 
 
24389 
  def __ne__(self, other):
24390 
    return not (self == other)
24391 
 
5527 anupam.sin 24392 
class setOrderAttributeForTransaction_args:
24393 
  """
24394 
  Attributes:
24395 
   - transactionId
24396 
   - attribute
24397 
  """
24398 
 
24399 
  thrift_spec = None
24400 
  def __init__(self, transactionId=None, attribute=None,):
24401 
    self.transactionId = transactionId
24402 
    self.attribute = attribute
24403 
 
24404 
  def read(self, iprot):
24405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24407 
      return
24408 
    iprot.readStructBegin()
24409 
    while True:
24410 
      (fname, ftype, fid) = iprot.readFieldBegin()
24411 
      if ftype == TType.STOP:
24412 
        break
24413 
      if fid == 1:
24414 
        if ftype == TType.I64:
24415 
          self.transactionId = iprot.readI64();
24416 
        else:
24417 
          iprot.skip(ftype)
24418 
      elif fid == -1:
24419 
        if ftype == TType.STRUCT:
24420 
          self.attribute = Attribute()
24421 
          self.attribute.read(iprot)
24422 
        else:
24423 
          iprot.skip(ftype)
24424 
      else:
24425 
        iprot.skip(ftype)
24426 
      iprot.readFieldEnd()
24427 
    iprot.readStructEnd()
24428 
 
24429 
  def write(self, oprot):
24430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24432 
      return
24433 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
24434 
    if self.attribute is not None:
24435 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
24436 
      self.attribute.write(oprot)
24437 
      oprot.writeFieldEnd()
24438 
    if self.transactionId is not None:
24439 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
24440 
      oprot.writeI64(self.transactionId)
24441 
      oprot.writeFieldEnd()
24442 
    oprot.writeFieldStop()
24443 
    oprot.writeStructEnd()
24444 
 
24445 
  def validate(self):
24446 
    return
24447 
 
24448 
 
24449 
  def __repr__(self):
24450 
    L = ['%s=%r' % (key, value)
24451 
      for key, value in self.__dict__.iteritems()]
24452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24453 
 
24454 
  def __eq__(self, other):
24455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24456 
 
24457 
  def __ne__(self, other):
24458 
    return not (self == other)
24459 
 
24460 
class setOrderAttributeForTransaction_result:
24461 
 
24462 
  thrift_spec = (
24463 
  )
24464 
 
24465 
  def read(self, iprot):
24466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24468 
      return
24469 
    iprot.readStructBegin()
24470 
    while True:
24471 
      (fname, ftype, fid) = iprot.readFieldBegin()
24472 
      if ftype == TType.STOP:
24473 
        break
24474 
      else:
24475 
        iprot.skip(ftype)
24476 
      iprot.readFieldEnd()
24477 
    iprot.readStructEnd()
24478 
 
24479 
  def write(self, oprot):
24480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24482 
      return
24483 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
24484 
    oprot.writeFieldStop()
24485 
    oprot.writeStructEnd()
24486 
 
24487 
  def validate(self):
24488 
    return
24489 
 
24490 
 
24491 
  def __repr__(self):
24492 
    L = ['%s=%r' % (key, value)
24493 
      for key, value in self.__dict__.iteritems()]
24494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24495 
 
24496 
  def __eq__(self, other):
24497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24498 
 
24499 
  def __ne__(self, other):
24500 
    return not (self == other)
5553 rajveer 24501 
 
24502 
class getReceivePendingOrders_args:
24503 
  """
24504 
  Attributes:
24505 
   - storeId
24506 
  """
24507 
 
24508 
  thrift_spec = (
24509 
    None, # 0
24510 
    (1, TType.I64, 'storeId', None, None, ), # 1
24511 
  )
24512 
 
24513 
  def __init__(self, storeId=None,):
24514 
    self.storeId = storeId
24515 
 
24516 
  def read(self, iprot):
24517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24519 
      return
24520 
    iprot.readStructBegin()
24521 
    while True:
24522 
      (fname, ftype, fid) = iprot.readFieldBegin()
24523 
      if ftype == TType.STOP:
24524 
        break
24525 
      if fid == 1:
24526 
        if ftype == TType.I64:
24527 
          self.storeId = iprot.readI64();
24528 
        else:
24529 
          iprot.skip(ftype)
24530 
      else:
24531 
        iprot.skip(ftype)
24532 
      iprot.readFieldEnd()
24533 
    iprot.readStructEnd()
24534 
 
24535 
  def write(self, oprot):
24536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24538 
      return
24539 
    oprot.writeStructBegin('getReceivePendingOrders_args')
24540 
    if self.storeId is not None:
24541 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
24542 
      oprot.writeI64(self.storeId)
24543 
      oprot.writeFieldEnd()
24544 
    oprot.writeFieldStop()
24545 
    oprot.writeStructEnd()
24546 
 
24547 
  def validate(self):
24548 
    return
24549 
 
24550 
 
24551 
  def __repr__(self):
24552 
    L = ['%s=%r' % (key, value)
24553 
      for key, value in self.__dict__.iteritems()]
24554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24555 
 
24556 
  def __eq__(self, other):
24557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24558 
 
24559 
  def __ne__(self, other):
24560 
    return not (self == other)
24561 
 
24562 
class getReceivePendingOrders_result:
24563 
  """
24564 
  Attributes:
24565 
   - success
24566 
  """
24567 
 
24568 
  thrift_spec = (
24569 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24570 
  )
24571 
 
24572 
  def __init__(self, success=None,):
24573 
    self.success = success
24574 
 
24575 
  def read(self, iprot):
24576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24578 
      return
24579 
    iprot.readStructBegin()
24580 
    while True:
24581 
      (fname, ftype, fid) = iprot.readFieldBegin()
24582 
      if ftype == TType.STOP:
24583 
        break
24584 
      if fid == 0:
24585 
        if ftype == TType.LIST:
24586 
          self.success = []
5713 rajveer 24587 
          (_etype595, _size592) = iprot.readListBegin()
24588 
          for _i596 in xrange(_size592):
24589 
            _elem597 = Order()
24590 
            _elem597.read(iprot)
24591 
            self.success.append(_elem597)
5553 rajveer 24592 
          iprot.readListEnd()
24593 
        else:
24594 
          iprot.skip(ftype)
24595 
      else:
24596 
        iprot.skip(ftype)
24597 
      iprot.readFieldEnd()
24598 
    iprot.readStructEnd()
24599 
 
24600 
  def write(self, oprot):
24601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24603 
      return
24604 
    oprot.writeStructBegin('getReceivePendingOrders_result')
24605 
    if self.success is not None:
24606 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24607 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 24608 
      for iter598 in self.success:
24609 
        iter598.write(oprot)
5553 rajveer 24610 
      oprot.writeListEnd()
24611 
      oprot.writeFieldEnd()
24612 
    oprot.writeFieldStop()
24613 
    oprot.writeStructEnd()
24614 
 
24615 
  def validate(self):
24616 
    return
24617 
 
24618 
 
24619 
  def __repr__(self):
24620 
    L = ['%s=%r' % (key, value)
24621 
      for key, value in self.__dict__.iteritems()]
24622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24623 
 
24624 
  def __eq__(self, other):
24625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24626 
 
24627 
  def __ne__(self, other):
24628 
    return not (self == other)
24629 
 
24630 
class getReceivedAtStoreOrders_args:
24631 
  """
24632 
  Attributes:
24633 
   - storeId
24634 
  """
24635 
 
24636 
  thrift_spec = (
24637 
    None, # 0
24638 
    (1, TType.I64, 'storeId', None, None, ), # 1
24639 
  )
24640 
 
24641 
  def __init__(self, storeId=None,):
24642 
    self.storeId = storeId
24643 
 
24644 
  def read(self, iprot):
24645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24647 
      return
24648 
    iprot.readStructBegin()
24649 
    while True:
24650 
      (fname, ftype, fid) = iprot.readFieldBegin()
24651 
      if ftype == TType.STOP:
24652 
        break
24653 
      if fid == 1:
24654 
        if ftype == TType.I64:
24655 
          self.storeId = iprot.readI64();
24656 
        else:
24657 
          iprot.skip(ftype)
24658 
      else:
24659 
        iprot.skip(ftype)
24660 
      iprot.readFieldEnd()
24661 
    iprot.readStructEnd()
24662 
 
24663 
  def write(self, oprot):
24664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24666 
      return
24667 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
24668 
    if self.storeId is not None:
24669 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
24670 
      oprot.writeI64(self.storeId)
24671 
      oprot.writeFieldEnd()
24672 
    oprot.writeFieldStop()
24673 
    oprot.writeStructEnd()
24674 
 
24675 
  def validate(self):
24676 
    return
24677 
 
24678 
 
24679 
  def __repr__(self):
24680 
    L = ['%s=%r' % (key, value)
24681 
      for key, value in self.__dict__.iteritems()]
24682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24683 
 
24684 
  def __eq__(self, other):
24685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24686 
 
24687 
  def __ne__(self, other):
24688 
    return not (self == other)
24689 
 
24690 
class getReceivedAtStoreOrders_result:
24691 
  """
24692 
  Attributes:
24693 
   - success
24694 
  """
24695 
 
24696 
  thrift_spec = (
24697 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24698 
  )
24699 
 
24700 
  def __init__(self, success=None,):
24701 
    self.success = success
24702 
 
24703 
  def read(self, iprot):
24704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24706 
      return
24707 
    iprot.readStructBegin()
24708 
    while True:
24709 
      (fname, ftype, fid) = iprot.readFieldBegin()
24710 
      if ftype == TType.STOP:
24711 
        break
24712 
      if fid == 0:
24713 
        if ftype == TType.LIST:
24714 
          self.success = []
5713 rajveer 24715 
          (_etype602, _size599) = iprot.readListBegin()
24716 
          for _i603 in xrange(_size599):
24717 
            _elem604 = Order()
24718 
            _elem604.read(iprot)
24719 
            self.success.append(_elem604)
5553 rajveer 24720 
          iprot.readListEnd()
24721 
        else:
24722 
          iprot.skip(ftype)
24723 
      else:
24724 
        iprot.skip(ftype)
24725 
      iprot.readFieldEnd()
24726 
    iprot.readStructEnd()
24727 
 
24728 
  def write(self, oprot):
24729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24731 
      return
24732 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
24733 
    if self.success is not None:
24734 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24735 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5713 rajveer 24736 
      for iter605 in self.success:
24737 
        iter605.write(oprot)
5553 rajveer 24738 
      oprot.writeListEnd()
24739 
      oprot.writeFieldEnd()
24740 
    oprot.writeFieldStop()
24741 
    oprot.writeStructEnd()
24742 
 
24743 
  def validate(self):
24744 
    return
24745 
 
24746 
 
24747 
  def __repr__(self):
24748 
    L = ['%s=%r' % (key, value)
24749 
      for key, value in self.__dict__.iteritems()]
24750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24751 
 
24752 
  def __eq__(self, other):
24753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24754 
 
24755 
  def __ne__(self, other):
24756 
    return not (self == other)
5593 mandeep.dh 24757 
 
5713 rajveer 24758 
class getOrdersCollectionAtStore_args:
24759 
  """
24760 
  Attributes:
24761 
   - storeId
24762 
   - fromDate
24763 
   - toDate
24764 
   - onlyCod
24765 
  """
24766 
 
24767 
  thrift_spec = (
24768 
    None, # 0
24769 
    (1, TType.I64, 'storeId', None, None, ), # 1
24770 
    (2, TType.I64, 'fromDate', None, None, ), # 2
24771 
    (3, TType.I64, 'toDate', None, None, ), # 3
24772 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
24773 
  )
24774 
 
24775 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
24776 
    self.storeId = storeId
24777 
    self.fromDate = fromDate
24778 
    self.toDate = toDate
24779 
    self.onlyCod = onlyCod
24780 
 
24781 
  def read(self, iprot):
24782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24784 
      return
24785 
    iprot.readStructBegin()
24786 
    while True:
24787 
      (fname, ftype, fid) = iprot.readFieldBegin()
24788 
      if ftype == TType.STOP:
24789 
        break
24790 
      if fid == 1:
24791 
        if ftype == TType.I64:
24792 
          self.storeId = iprot.readI64();
24793 
        else:
24794 
          iprot.skip(ftype)
24795 
      elif fid == 2:
24796 
        if ftype == TType.I64:
24797 
          self.fromDate = iprot.readI64();
24798 
        else:
24799 
          iprot.skip(ftype)
24800 
      elif fid == 3:
24801 
        if ftype == TType.I64:
24802 
          self.toDate = iprot.readI64();
24803 
        else:
24804 
          iprot.skip(ftype)
24805 
      elif fid == 4:
24806 
        if ftype == TType.BOOL:
24807 
          self.onlyCod = iprot.readBool();
24808 
        else:
24809 
          iprot.skip(ftype)
24810 
      else:
24811 
        iprot.skip(ftype)
24812 
      iprot.readFieldEnd()
24813 
    iprot.readStructEnd()
24814 
 
24815 
  def write(self, oprot):
24816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24818 
      return
24819 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
24820 
    if self.storeId is not None:
24821 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
24822 
      oprot.writeI64(self.storeId)
24823 
      oprot.writeFieldEnd()
24824 
    if self.fromDate is not None:
24825 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
24826 
      oprot.writeI64(self.fromDate)
24827 
      oprot.writeFieldEnd()
24828 
    if self.toDate is not None:
24829 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
24830 
      oprot.writeI64(self.toDate)
24831 
      oprot.writeFieldEnd()
24832 
    if self.onlyCod is not None:
24833 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
24834 
      oprot.writeBool(self.onlyCod)
24835 
      oprot.writeFieldEnd()
24836 
    oprot.writeFieldStop()
24837 
    oprot.writeStructEnd()
24838 
 
24839 
  def validate(self):
24840 
    return
24841 
 
24842 
 
24843 
  def __repr__(self):
24844 
    L = ['%s=%r' % (key, value)
24845 
      for key, value in self.__dict__.iteritems()]
24846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24847 
 
24848 
  def __eq__(self, other):
24849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24850 
 
24851 
  def __ne__(self, other):
24852 
    return not (self == other)
24853 
 
24854 
class getOrdersCollectionAtStore_result:
24855 
  """
24856 
  Attributes:
24857 
   - success
24858 
  """
24859 
 
24860 
  thrift_spec = (
24861 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24862 
  )
24863 
 
24864 
  def __init__(self, success=None,):
24865 
    self.success = success
24866 
 
24867 
  def read(self, iprot):
24868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24870 
      return
24871 
    iprot.readStructBegin()
24872 
    while True:
24873 
      (fname, ftype, fid) = iprot.readFieldBegin()
24874 
      if ftype == TType.STOP:
24875 
        break
24876 
      if fid == 0:
24877 
        if ftype == TType.LIST:
24878 
          self.success = []
24879 
          (_etype609, _size606) = iprot.readListBegin()
24880 
          for _i610 in xrange(_size606):
24881 
            _elem611 = Order()
24882 
            _elem611.read(iprot)
24883 
            self.success.append(_elem611)
24884 
          iprot.readListEnd()
24885 
        else:
24886 
          iprot.skip(ftype)
24887 
      else:
24888 
        iprot.skip(ftype)
24889 
      iprot.readFieldEnd()
24890 
    iprot.readStructEnd()
24891 
 
24892 
  def write(self, oprot):
24893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24895 
      return
24896 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
24897 
    if self.success is not None:
24898 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24899 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
24900 
      for iter612 in self.success:
24901 
        iter612.write(oprot)
24902 
      oprot.writeListEnd()
24903 
      oprot.writeFieldEnd()
24904 
    oprot.writeFieldStop()
24905 
    oprot.writeStructEnd()
24906 
 
24907 
  def validate(self):
24908 
    return
24909 
 
24910 
 
24911 
  def __repr__(self):
24912 
    L = ['%s=%r' % (key, value)
24913 
      for key, value in self.__dict__.iteritems()]
24914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24915 
 
24916 
  def __eq__(self, other):
24917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24918 
 
24919 
  def __ne__(self, other):
24920 
    return not (self == other)
24921 
 
5593 mandeep.dh 24922 
class acceptOrderForItem_args:
24923 
  """
24924 
  Attributes:
24925 
   - itemId
24926 
   - quantity
24927 
   - fulfilmentWarehouseId
24928 
   - billingWarehouseId
24929 
  """
24930 
 
24931 
  thrift_spec = (
24932 
    None, # 0
24933 
    (1, TType.I64, 'itemId', None, None, ), # 1
24934 
    (2, TType.I64, 'quantity', None, None, ), # 2
24935 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
24936 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
24937 
  )
24938 
 
24939 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
24940 
    self.itemId = itemId
24941 
    self.quantity = quantity
24942 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
24943 
    self.billingWarehouseId = billingWarehouseId
24944 
 
24945 
  def read(self, iprot):
24946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24948 
      return
24949 
    iprot.readStructBegin()
24950 
    while True:
24951 
      (fname, ftype, fid) = iprot.readFieldBegin()
24952 
      if ftype == TType.STOP:
24953 
        break
24954 
      if fid == 1:
24955 
        if ftype == TType.I64:
24956 
          self.itemId = iprot.readI64();
24957 
        else:
24958 
          iprot.skip(ftype)
24959 
      elif fid == 2:
24960 
        if ftype == TType.I64:
24961 
          self.quantity = iprot.readI64();
24962 
        else:
24963 
          iprot.skip(ftype)
24964 
      elif fid == 3:
24965 
        if ftype == TType.I64:
24966 
          self.fulfilmentWarehouseId = iprot.readI64();
24967 
        else:
24968 
          iprot.skip(ftype)
24969 
      elif fid == 4:
24970 
        if ftype == TType.I64:
24971 
          self.billingWarehouseId = iprot.readI64();
24972 
        else:
24973 
          iprot.skip(ftype)
24974 
      else:
24975 
        iprot.skip(ftype)
24976 
      iprot.readFieldEnd()
24977 
    iprot.readStructEnd()
24978 
 
24979 
  def write(self, oprot):
24980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24982 
      return
24983 
    oprot.writeStructBegin('acceptOrderForItem_args')
24984 
    if self.itemId is not None:
24985 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
24986 
      oprot.writeI64(self.itemId)
24987 
      oprot.writeFieldEnd()
24988 
    if self.quantity is not None:
24989 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
24990 
      oprot.writeI64(self.quantity)
24991 
      oprot.writeFieldEnd()
24992 
    if self.fulfilmentWarehouseId is not None:
24993 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
24994 
      oprot.writeI64(self.fulfilmentWarehouseId)
24995 
      oprot.writeFieldEnd()
24996 
    if self.billingWarehouseId is not None:
24997 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
24998 
      oprot.writeI64(self.billingWarehouseId)
24999 
      oprot.writeFieldEnd()
25000 
    oprot.writeFieldStop()
25001 
    oprot.writeStructEnd()
25002 
 
25003 
  def validate(self):
25004 
    return
25005 
 
25006 
 
25007 
  def __repr__(self):
25008 
    L = ['%s=%r' % (key, value)
25009 
      for key, value in self.__dict__.iteritems()]
25010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25011 
 
25012 
  def __eq__(self, other):
25013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25014 
 
25015 
  def __ne__(self, other):
25016 
    return not (self == other)
25017 
 
25018 
class acceptOrderForItem_result:
25019 
 
25020 
  thrift_spec = (
25021 
  )
25022 
 
25023 
  def read(self, iprot):
25024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25026 
      return
25027 
    iprot.readStructBegin()
25028 
    while True:
25029 
      (fname, ftype, fid) = iprot.readFieldBegin()
25030 
      if ftype == TType.STOP:
25031 
        break
25032 
      else:
25033 
        iprot.skip(ftype)
25034 
      iprot.readFieldEnd()
25035 
    iprot.readStructEnd()
25036 
 
25037 
  def write(self, oprot):
25038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25040 
      return
25041 
    oprot.writeStructBegin('acceptOrderForItem_result')
25042 
    oprot.writeFieldStop()
25043 
    oprot.writeStructEnd()
25044 
 
25045 
  def validate(self):
25046 
    return
25047 
 
25048 
 
25049 
  def __repr__(self):
25050 
    L = ['%s=%r' % (key, value)
25051 
      for key, value in self.__dict__.iteritems()]
25052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25053 
 
25054 
  def __eq__(self, other):
25055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25056 
 
25057 
  def __ne__(self, other):
25058 
    return not (self == other)