Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
2 
# Autogenerated by Thrift
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
from ttypes import *
9 
from thrift.Thrift import TProcessor
10 
from thrift.transport import TTransport
11 
from thrift.protocol import TBinaryProtocol
12 
try:
13 
  from thrift.protocol import fastbinary
14 
except:
15 
  fastbinary = None
16 
 
17 
 
18 
class Iface:
765 rajveer 19 
  def closeSession(self, ):
20 
    """
21 
    For closing the open session in sqlalchemy
22 
    """
23 
    pass
24 
 
94 ashish 25 
  def createTransaction(self, transaction):
26 
    """
27 
    Parameters:
28 
     - transaction
29 
    """
30 
    pass
31 
 
32 
  def getTransaction(self, id):
33 
    """
34 
    Parameters:
35 
     - id
36 
    """
37 
    pass
38 
 
39 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
40 
    """
41 
    Parameters:
42 
     - customerId
43 
     - from_date
44 
     - to_date
45 
     - status
46 
    """
47 
    pass
48 
 
132 ashish 49 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
50 
    """
51 
    Parameters:
52 
     - shoppingCartId
53 
    """
54 
    pass
55 
 
94 ashish 56 
  def getTransactionStatus(self, transactionId):
57 
    """
58 
    Parameters:
59 
     - transactionId
60 
    """
61 
    pass
62 
 
63 
  def changeTransactionStatus(self, transactionId, status, description):
64 
    """
65 
    Parameters:
66 
     - transactionId
67 
     - status
68 
     - description
69 
    """
70 
    pass
71 
 
1398 varun.gupt 72 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 73 
    """
74 
    Parameters:
75 
     - transactionId
76 
    """
77 
    pass
78 
 
483 rajveer 79 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 80 
    """
81 
    Parameters:
483 rajveer 82 
     - status
83 
     - from_date
84 
     - to_date
85 
     - warehouse_id
94 ashish 86 
    """
87 
    pass
88 
 
999 varun.gupt 89 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
90 
    """
1132 chandransh 91 
    Returns orders within a range of their billing dates
92 
 
999 varun.gupt 93 
    Parameters:
94 
     - status
95 
     - start_billing_date
96 
     - end_billing_date
97 
     - warehouse_id
98 
    """
99 
    pass
100 
 
1382 varun.gupt 101 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
102 
    """
103 
    Returns order ids for orders which can be returned
104 
 
105 
    Parameters:
106 
     - customer_id
107 
     - limit
108 
    """
109 
    pass
110 
 
111 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
112 
    """
113 
    Returns order ids for orders which can be cancelled
114 
 
115 
    Parameters:
116 
     - customer_id
117 
     - limit
118 
    """
119 
    pass
120 
 
483 rajveer 121 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 122 
    """
123 
    Parameters:
483 rajveer 124 
     - orderId
125 
     - status
126 
     - description
94 ashish 127 
    """
128 
    pass
129 
 
1149 chandransh 130 
  def addBillingDetails(self, orderId, invoice_number, billed_by):
494 rajveer 131 
    """
1149 chandransh 132 
    Add billing details such as the bill number and the biller to the Order.
133 
 
494 rajveer 134 
    Parameters:
135 
     - orderId
136 
     - invoice_number
137 
     - billed_by
138 
    """
139 
    pass
140 
 
2842 chandransh 141 
  def addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
1149 chandransh 142 
    """
2446 chandransh 143 
    Adds jacket number and IMEI no. to the order. Doesn't update the IMEI no. if a -1 is supplied.
144 
    Also marks the order as billed and sets the billing timestamp.
145 
    Return false if it doesn't find the order with the given ID.
1149 chandransh 146 
 
147 
    Parameters:
148 
     - orderId
149 
     - jacketNumber
2783 chandransh 150 
     - imeiNumber
151 
     - itemNumber
152 
     - billedBy
2842 chandransh 153 
     - billingType
1149 chandransh 154 
    """
155 
    pass
156 
 
921 rajveer 157 
  def acceptOrder(self, orderId):
158 
    """
159 
    Parameters:
160 
     - orderId
161 
    """
162 
    pass
163 
 
164 
  def billOrder(self, orderId):
165 
    """
166 
    Parameters:
167 
     - orderId
168 
    """
169 
    pass
170 
 
1528 ankur.sing 171 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 172 
    """
1528 ankur.sing 173 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
174 
    only user who owns the transaction can view its order details.
175 
 
94 ashish 176 
    Parameters:
177 
     - transactionId
1528 ankur.sing 178 
     - customerId
94 ashish 179 
    """
180 
    pass
181 
 
3014 chandransh 182 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 183 
    """
3014 chandransh 184 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
185 
    Pass and empty list to ignore filtering on statuses.
186 
 
94 ashish 187 
    Parameters:
483 rajveer 188 
     - customerId
189 
     - from_date
190 
     - to_date
3014 chandransh 191 
     - statuses
94 ashish 192 
    """
193 
    pass
194 
 
483 rajveer 195 
  def createOrder(self, order):
94 ashish 196 
    """
197 
    Parameters:
483 rajveer 198 
     - order
94 ashish 199 
    """
200 
    pass
201 
 
483 rajveer 202 
  def getOrder(self, id):
94 ashish 203 
    """
204 
    Parameters:
483 rajveer 205 
     - id
94 ashish 206 
    """
207 
    pass
208 
 
483 rajveer 209 
  def getLineItemsForOrder(self, orderId):
94 ashish 210 
    """
211 
    Parameters:
483 rajveer 212 
     - orderId
94 ashish 213 
    """
214 
    pass
215 
 
1528 ankur.sing 216 
  def getOrderForCustomer(self, orderId, customerId):
217 
    """
218 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
219 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
220 
 
221 
    Parameters:
222 
     - orderId
223 
     - customerId
224 
    """
225 
    pass
226 
 
1220 chandransh 227 
  def batchOrders(self, warehouseId):
228 
    """
229 
    Create a batch of all the pending orders for the given warehouse.
230 
    The returned list is orderd by created_timestamp.
231 
    If there are no pending orders, an empty list is returned.
232 
 
233 
    Parameters:
234 
     - warehouseId
235 
    """
236 
    pass
237 
 
1208 chandransh 238 
  def markOrderAsOutOfStock(self, orderId):
239 
    """
240 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
241 
 
242 
    Parameters:
243 
     - orderId
244 
    """
245 
    pass
246 
 
759 chandransh 247 
  def markOrdersAsManifested(self, warehouseId, providerId):
248 
    """
249 
    Marks all BILLED orders for a warehouse and a provider as SHIPPED_FROM_WH
250 
 
251 
    Parameters:
252 
     - warehouseId
253 
     - providerId
254 
    """
255 
    pass
256 
 
1113 chandransh 257 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
258 
    """
259 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
260 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
261 
    Raises an exception if we encounter report for an AWB number that we did not ship.
262 
 
263 
    Parameters:
264 
     - providerId
265 
     - pickupDetails
266 
    """
267 
    pass
268 
 
1132 chandransh 269 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
270 
    """
271 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
272 
    the name of the receiver.
273 
    Raises an exception if we encounter report for an AWB number that we did not ship.
274 
 
275 
    Parameters:
276 
     - providerId
277 
     - deliveredOrders
278 
    """
279 
    pass
280 
 
1135 chandransh 281 
  def markOrdersAsFailed(self, providerId, returnedOrders):
282 
    """
283 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
284 
    Raises an exception if we encounter report for an AWB number that we did not ship.
285 
 
286 
    Parameters:
287 
     - providerId
288 
     - returnedOrders
289 
    """
290 
    pass
291 
 
1246 chandransh 292 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
293 
    """
294 
    Update the status description of orders whose AWB numbers are keys of the Map.
295 
 
296 
    Parameters:
297 
     - providerId
298 
     - undeliveredOrders
299 
    """
300 
    pass
301 
 
1408 ankur.sing 302 
  def getUndeliveredOrders(self, providerId, warehouseId):
303 
    """
304 
    Returns the list of orders whose delivery time has passed but have not been
305 
    delivered yet for the given provider and warehouse. To get a complete list of
306 
    undelivered orders, pass them as -1.
307 
    Returns an empty list if no such orders exist.
308 
 
309 
    Parameters:
310 
     - providerId
311 
     - warehouseId
312 
    """
313 
    pass
314 
 
483 rajveer 315 
  def getAlerts(self, orderId, valid):
94 ashish 316 
    """
317 
    Parameters:
483 rajveer 318 
     - orderId
304 ashish 319 
     - valid
320 
    """
321 
    pass
94 ashish 322 
 
483 rajveer 323 
  def setAlert(self, orderId, unset, type, comment):
304 ashish 324 
    """
325 
    Parameters:
483 rajveer 326 
     - orderId
304 ashish 327 
     - unset
328 
     - type
329 
     - comment
330 
    """
331 
    pass
332 
 
1596 ankur.sing 333 
  def getValidOrderCount(self, ):
334 
    """
335 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
336 
    """
337 
    pass
304 ashish 338 
 
1627 ankur.sing 339 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
340 
    """
341 
    Returns the number of distinct customers who have done successful transactions
342 
    """
343 
    pass
1596 ankur.sing 344 
 
1731 ankur.sing 345 
  def getValidOrdersAmountRange(self, ):
1627 ankur.sing 346 
    """
1731 ankur.sing 347 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
348 
    List contains two values, first minimum amount and second maximum amount.
1627 ankur.sing 349 
    """
350 
    pass
351 
 
1886 ankur.sing 352 
  def getValidOrders(self, limit):
353 
    """
354 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
355 
    If limit is passed as 0, then all valid Orders are returned.
356 
 
357 
    Parameters:
358 
     - limit
359 
    """
360 
    pass
1627 ankur.sing 361 
 
2536 chandransh 362 
  def toggleDOAFlag(self, orderId):
363 
    """
364 
    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.
365 
    Returns the final flag status.
366 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
367 
 
368 
    Parameters:
369 
     - orderId
370 
    """
371 
    pass
1886 ankur.sing 372 
 
2536 chandransh 373 
  def requestPickupNumber(self, orderId):
374 
    """
375 
    Sends out an email to the account manager of the original courier provider used to ship the order.
376 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
377 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
378 
    For any other status, it returns false.
379 
    Throws an exception if the order with the given id couldn't be found.
380 
 
381 
    Parameters:
382 
     - orderId
383 
    """
384 
    pass
385 
 
386 
  def authorizePickup(self, orderId, pickupNumber):
387 
    """
388 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
389 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
390 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
391 
    	3. Returns true
2591 chandransh 392 
    If the order is in any other status, it returns false.
2536 chandransh 393 
    Throws an exception if the order with the given id couldn't be found.
394 
 
395 
    Parameters:
396 
     - orderId
397 
     - pickupNumber
398 
    """
399 
    pass
400 
 
2764 chandransh 401 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
402 
    """
403 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
404 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
405 
 
406 
    Parameters:
407 
     - providerId
408 
     - pickupDetails
409 
    """
410 
    pass
411 
 
2616 chandransh 412 
  def receiveReturn(self, orderId):
2591 chandransh 413 
    """
2599 chandransh 414 
    If the order status is DOA_RETURN_AUTHORIZED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED and returns true.
2616 chandransh 415 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 416 
    If the order is in any other state, it returns false.
417 
    Throws an exception if the order with the given id couldn't be found.
418 
 
419 
    Parameters:
420 
     - orderId
421 
    """
422 
    pass
2536 chandransh 423 
 
2591 chandransh 424 
  def validateDoa(self, orderId, isValid):
425 
    """
2599 chandransh 426 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 427 
    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 428 
    If the order is in any other state, it returns false.
429 
    Throws an exception if the order with the given id couldn't be found.
430 
 
431 
    Parameters:
432 
     - orderId
433 
     - isValid
434 
    """
435 
    pass
436 
 
2616 chandransh 437 
  def reshipOrder(self, orderId):
438 
    """
439 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
440 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
441 
    	2. Marks the current order as one of the final states SALES_RET_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
442 
 
443 
    If the order is in DOA_CERT_VALID state, it does the following:
444 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
445 
    	2. Creates a return order for the warehouse executive to return the DOA material.
446 
    	3. Marks the current order as the final DOA_RESHIPPED state.
447 
 
448 
    Returns the id of the newly created order.
449 
 
450 
    Throws an exception if the order with the given id couldn't be found.
451 
 
452 
    Parameters:
453 
     - orderId
454 
    """
455 
    pass
2591 chandransh 456 
 
2616 chandransh 457 
  def refundOrder(self, orderId):
458 
    """
459 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
460 
    	1. Creates a refund request for batch processing.
461 
    	2. Creates a return order for the warehouse executive to return the shipped material.
462 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
463 
 
464 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
465 
    	1. Creates a refund request for batch processing.
466 
    	2. Marks the current order as the REFUNDED final state.
467 
 
468 
    Returns True if it is successful, False otherwise.
469 
 
470 
    Throws an exception if the order with the given id couldn't be found.
471 
 
472 
    Parameters:
473 
     - orderId
474 
    """
475 
    pass
476 
 
2690 chandransh 477 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
478 
    """
479 
    Get all return orders created between the from and to dates for the given warehouse.
480 
    Ignores the warehouse if it is passed as -1.
481 
 
482 
    Parameters:
483 
     - warehouseId
484 
     - fromDate
485 
     - toDate
486 
    """
487 
    pass
2616 chandransh 488 
 
2700 chandransh 489 
  def getReturnOrder(self, id):
490 
    """
491 
    Returns the ReturnOrder corresponding to the given id.
492 
    Throws an exception if the return order with the given id couldn't be found.
493 
 
494 
    Parameters:
495 
     - id
496 
    """
497 
    pass
498 
 
2690 chandransh 499 
  def processReturn(self, returnOrderId):
500 
    """
501 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
502 
 
503 
    Parameters:
504 
     - returnOrderId
505 
    """
506 
    pass
507 
 
2819 chandransh 508 
  def createPurchaseOrder(self, warehouseId):
509 
    """
510 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 511 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
2819 chandransh 512 
 
513 
    Parameters:
514 
     - warehouseId
515 
    """
516 
    pass
2690 chandransh 517 
 
2819 chandransh 518 
 
94 ashish 519 
class Client(Iface):
520 
  def __init__(self, iprot, oprot=None):
521 
    self._iprot = self._oprot = iprot
522 
    if oprot != None:
523 
      self._oprot = oprot
524 
    self._seqid = 0
525 
 
765 rajveer 526 
  def closeSession(self, ):
527 
    """
528 
    For closing the open session in sqlalchemy
529 
    """
530 
    self.send_closeSession()
531 
    self.recv_closeSession()
532 
 
533 
  def send_closeSession(self, ):
534 
    self._oprot.writeMessageBegin('closeSession', TMessageType.CALL, self._seqid)
535 
    args = closeSession_args()
536 
    args.write(self._oprot)
537 
    self._oprot.writeMessageEnd()
538 
    self._oprot.trans.flush()
539 
 
540 
  def recv_closeSession(self, ):
541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
542 
    if mtype == TMessageType.EXCEPTION:
543 
      x = TApplicationException()
544 
      x.read(self._iprot)
545 
      self._iprot.readMessageEnd()
546 
      raise x
547 
    result = closeSession_result()
548 
    result.read(self._iprot)
549 
    self._iprot.readMessageEnd()
550 
    return
551 
 
94 ashish 552 
  def createTransaction(self, transaction):
553 
    """
554 
    Parameters:
555 
     - transaction
556 
    """
557 
    self.send_createTransaction(transaction)
132 ashish 558 
    return self.recv_createTransaction()
94 ashish 559 
 
560 
  def send_createTransaction(self, transaction):
561 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
562 
    args = createTransaction_args()
563 
    args.transaction = transaction
564 
    args.write(self._oprot)
565 
    self._oprot.writeMessageEnd()
566 
    self._oprot.trans.flush()
567 
 
568 
  def recv_createTransaction(self, ):
569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
570 
    if mtype == TMessageType.EXCEPTION:
571 
      x = TApplicationException()
572 
      x.read(self._iprot)
573 
      self._iprot.readMessageEnd()
574 
      raise x
575 
    result = createTransaction_result()
576 
    result.read(self._iprot)
577 
    self._iprot.readMessageEnd()
132 ashish 578 
    if result.success != None:
579 
      return result.success
94 ashish 580 
    if result.ex != None:
581 
      raise result.ex
132 ashish 582 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 583 
 
584 
  def getTransaction(self, id):
585 
    """
586 
    Parameters:
587 
     - id
588 
    """
589 
    self.send_getTransaction(id)
590 
    return self.recv_getTransaction()
591 
 
592 
  def send_getTransaction(self, id):
593 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
594 
    args = getTransaction_args()
595 
    args.id = id
596 
    args.write(self._oprot)
597 
    self._oprot.writeMessageEnd()
598 
    self._oprot.trans.flush()
599 
 
600 
  def recv_getTransaction(self, ):
601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
602 
    if mtype == TMessageType.EXCEPTION:
603 
      x = TApplicationException()
604 
      x.read(self._iprot)
605 
      self._iprot.readMessageEnd()
606 
      raise x
607 
    result = getTransaction_result()
608 
    result.read(self._iprot)
609 
    self._iprot.readMessageEnd()
610 
    if result.success != None:
611 
      return result.success
612 
    if result.ex != None:
613 
      raise result.ex
614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
615 
 
616 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
617 
    """
618 
    Parameters:
619 
     - customerId
620 
     - from_date
621 
     - to_date
622 
     - status
623 
    """
624 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
625 
    return self.recv_getTransactionsForCustomer()
626 
 
627 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
628 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
629 
    args = getTransactionsForCustomer_args()
630 
    args.customerId = customerId
631 
    args.from_date = from_date
632 
    args.to_date = to_date
633 
    args.status = status
634 
    args.write(self._oprot)
635 
    self._oprot.writeMessageEnd()
636 
    self._oprot.trans.flush()
637 
 
638 
  def recv_getTransactionsForCustomer(self, ):
639 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
640 
    if mtype == TMessageType.EXCEPTION:
641 
      x = TApplicationException()
642 
      x.read(self._iprot)
643 
      self._iprot.readMessageEnd()
644 
      raise x
645 
    result = getTransactionsForCustomer_result()
646 
    result.read(self._iprot)
647 
    self._iprot.readMessageEnd()
648 
    if result.success != None:
649 
      return result.success
650 
    if result.ex != None:
651 
      raise result.ex
652 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
653 
 
132 ashish 654 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
655 
    """
656 
    Parameters:
657 
     - shoppingCartId
658 
    """
659 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
660 
    return self.recv_getTransactionsForShoppingCartId()
661 
 
662 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
663 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
664 
    args = getTransactionsForShoppingCartId_args()
665 
    args.shoppingCartId = shoppingCartId
666 
    args.write(self._oprot)
667 
    self._oprot.writeMessageEnd()
668 
    self._oprot.trans.flush()
669 
 
670 
  def recv_getTransactionsForShoppingCartId(self, ):
671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
672 
    if mtype == TMessageType.EXCEPTION:
673 
      x = TApplicationException()
674 
      x.read(self._iprot)
675 
      self._iprot.readMessageEnd()
676 
      raise x
677 
    result = getTransactionsForShoppingCartId_result()
678 
    result.read(self._iprot)
679 
    self._iprot.readMessageEnd()
680 
    if result.success != None:
681 
      return result.success
682 
    if result.ex != None:
683 
      raise result.ex
684 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
685 
 
94 ashish 686 
  def getTransactionStatus(self, transactionId):
687 
    """
688 
    Parameters:
689 
     - transactionId
690 
    """
691 
    self.send_getTransactionStatus(transactionId)
692 
    return self.recv_getTransactionStatus()
693 
 
694 
  def send_getTransactionStatus(self, transactionId):
695 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
696 
    args = getTransactionStatus_args()
697 
    args.transactionId = transactionId
698 
    args.write(self._oprot)
699 
    self._oprot.writeMessageEnd()
700 
    self._oprot.trans.flush()
701 
 
702 
  def recv_getTransactionStatus(self, ):
703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
704 
    if mtype == TMessageType.EXCEPTION:
705 
      x = TApplicationException()
706 
      x.read(self._iprot)
707 
      self._iprot.readMessageEnd()
708 
      raise x
709 
    result = getTransactionStatus_result()
710 
    result.read(self._iprot)
711 
    self._iprot.readMessageEnd()
712 
    if result.success != None:
713 
      return result.success
714 
    if result.ex != None:
715 
      raise result.ex
716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
717 
 
718 
  def changeTransactionStatus(self, transactionId, status, description):
719 
    """
720 
    Parameters:
721 
     - transactionId
722 
     - status
723 
     - description
724 
    """
725 
    self.send_changeTransactionStatus(transactionId, status, description)
726 
    return self.recv_changeTransactionStatus()
727 
 
728 
  def send_changeTransactionStatus(self, transactionId, status, description):
729 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
730 
    args = changeTransactionStatus_args()
731 
    args.transactionId = transactionId
732 
    args.status = status
733 
    args.description = description
734 
    args.write(self._oprot)
735 
    self._oprot.writeMessageEnd()
736 
    self._oprot.trans.flush()
737 
 
738 
  def recv_changeTransactionStatus(self, ):
739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
740 
    if mtype == TMessageType.EXCEPTION:
741 
      x = TApplicationException()
742 
      x.read(self._iprot)
743 
      self._iprot.readMessageEnd()
744 
      raise x
745 
    result = changeTransactionStatus_result()
746 
    result.read(self._iprot)
747 
    self._iprot.readMessageEnd()
748 
    if result.success != None:
749 
      return result.success
750 
    if result.ex != None:
751 
      raise result.ex
752 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
753 
 
1398 varun.gupt 754 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 755 
    """
756 
    Parameters:
757 
     - transactionId
758 
    """
1398 varun.gupt 759 
    self.send_enqueueTransactionInfoEmail(transactionId)
760 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 761 
 
1398 varun.gupt 762 
  def send_enqueueTransactionInfoEmail(self, transactionId):
763 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
764 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 765 
    args.transactionId = transactionId
766 
    args.write(self._oprot)
767 
    self._oprot.writeMessageEnd()
768 
    self._oprot.trans.flush()
769 
 
1398 varun.gupt 770 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
772 
    if mtype == TMessageType.EXCEPTION:
773 
      x = TApplicationException()
774 
      x.read(self._iprot)
775 
      self._iprot.readMessageEnd()
776 
      raise x
1398 varun.gupt 777 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 778 
    result.read(self._iprot)
779 
    self._iprot.readMessageEnd()
780 
    if result.success != None:
781 
      return result.success
782 
    if result.ex != None:
783 
      raise result.ex
1398 varun.gupt 784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 785 
 
483 rajveer 786 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 787 
    """
788 
    Parameters:
483 rajveer 789 
     - status
790 
     - from_date
791 
     - to_date
792 
     - warehouse_id
94 ashish 793 
    """
483 rajveer 794 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
795 
    return self.recv_getAllOrders()
94 ashish 796 
 
483 rajveer 797 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
798 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
799 
    args = getAllOrders_args()
800 
    args.status = status
801 
    args.from_date = from_date
802 
    args.to_date = to_date
803 
    args.warehouse_id = warehouse_id
94 ashish 804 
    args.write(self._oprot)
805 
    self._oprot.writeMessageEnd()
806 
    self._oprot.trans.flush()
807 
 
483 rajveer 808 
  def recv_getAllOrders(self, ):
94 ashish 809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
810 
    if mtype == TMessageType.EXCEPTION:
811 
      x = TApplicationException()
812 
      x.read(self._iprot)
813 
      self._iprot.readMessageEnd()
814 
      raise x
483 rajveer 815 
    result = getAllOrders_result()
94 ashish 816 
    result.read(self._iprot)
817 
    self._iprot.readMessageEnd()
818 
    if result.success != None:
819 
      return result.success
820 
    if result.ex != None:
821 
      raise result.ex
483 rajveer 822 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 823 
 
999 varun.gupt 824 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
825 
    """
1132 chandransh 826 
    Returns orders within a range of their billing dates
827 
 
999 varun.gupt 828 
    Parameters:
829 
     - status
830 
     - start_billing_date
831 
     - end_billing_date
832 
     - warehouse_id
833 
    """
834 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
835 
    return self.recv_getOrdersByBillingDate()
836 
 
837 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
838 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
839 
    args = getOrdersByBillingDate_args()
840 
    args.status = status
841 
    args.start_billing_date = start_billing_date
842 
    args.end_billing_date = end_billing_date
843 
    args.warehouse_id = warehouse_id
844 
    args.write(self._oprot)
845 
    self._oprot.writeMessageEnd()
846 
    self._oprot.trans.flush()
847 
 
848 
  def recv_getOrdersByBillingDate(self, ):
849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
850 
    if mtype == TMessageType.EXCEPTION:
851 
      x = TApplicationException()
852 
      x.read(self._iprot)
853 
      self._iprot.readMessageEnd()
854 
      raise x
855 
    result = getOrdersByBillingDate_result()
856 
    result.read(self._iprot)
857 
    self._iprot.readMessageEnd()
858 
    if result.success != None:
859 
      return result.success
860 
    if result.ex != None:
861 
      raise result.ex
862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
863 
 
1382 varun.gupt 864 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
865 
    """
866 
    Returns order ids for orders which can be returned
867 
 
868 
    Parameters:
869 
     - customer_id
870 
     - limit
871 
    """
872 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
873 
    return self.recv_getReturnableOrdersForCustomer()
874 
 
875 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
876 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
877 
    args = getReturnableOrdersForCustomer_args()
878 
    args.customer_id = customer_id
879 
    args.limit = limit
880 
    args.write(self._oprot)
881 
    self._oprot.writeMessageEnd()
882 
    self._oprot.trans.flush()
883 
 
884 
  def recv_getReturnableOrdersForCustomer(self, ):
885 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
886 
    if mtype == TMessageType.EXCEPTION:
887 
      x = TApplicationException()
888 
      x.read(self._iprot)
889 
      self._iprot.readMessageEnd()
890 
      raise x
891 
    result = getReturnableOrdersForCustomer_result()
892 
    result.read(self._iprot)
893 
    self._iprot.readMessageEnd()
894 
    if result.success != None:
895 
      return result.success
896 
    if result.ex != None:
897 
      raise result.ex
898 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
899 
 
900 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
901 
    """
902 
    Returns order ids for orders which can be cancelled
903 
 
904 
    Parameters:
905 
     - customer_id
906 
     - limit
907 
    """
908 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
909 
    return self.recv_getCancellableOrdersForCustomer()
910 
 
911 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
912 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
913 
    args = getCancellableOrdersForCustomer_args()
914 
    args.customer_id = customer_id
915 
    args.limit = limit
916 
    args.write(self._oprot)
917 
    self._oprot.writeMessageEnd()
918 
    self._oprot.trans.flush()
919 
 
920 
  def recv_getCancellableOrdersForCustomer(self, ):
921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
922 
    if mtype == TMessageType.EXCEPTION:
923 
      x = TApplicationException()
924 
      x.read(self._iprot)
925 
      self._iprot.readMessageEnd()
926 
      raise x
927 
    result = getCancellableOrdersForCustomer_result()
928 
    result.read(self._iprot)
929 
    self._iprot.readMessageEnd()
930 
    if result.success != None:
931 
      return result.success
932 
    if result.ex != None:
933 
      raise result.ex
934 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
935 
 
483 rajveer 936 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 937 
    """
938 
    Parameters:
483 rajveer 939 
     - orderId
940 
     - status
941 
     - description
94 ashish 942 
    """
483 rajveer 943 
    self.send_changeOrderStatus(orderId, status, description)
944 
    return self.recv_changeOrderStatus()
94 ashish 945 
 
483 rajveer 946 
  def send_changeOrderStatus(self, orderId, status, description):
947 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
948 
    args = changeOrderStatus_args()
949 
    args.orderId = orderId
950 
    args.status = status
951 
    args.description = description
94 ashish 952 
    args.write(self._oprot)
953 
    self._oprot.writeMessageEnd()
954 
    self._oprot.trans.flush()
955 
 
483 rajveer 956 
  def recv_changeOrderStatus(self, ):
94 ashish 957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
958 
    if mtype == TMessageType.EXCEPTION:
959 
      x = TApplicationException()
960 
      x.read(self._iprot)
961 
      self._iprot.readMessageEnd()
962 
      raise x
483 rajveer 963 
    result = changeOrderStatus_result()
94 ashish 964 
    result.read(self._iprot)
965 
    self._iprot.readMessageEnd()
966 
    if result.success != None:
967 
      return result.success
968 
    if result.ex != None:
969 
      raise result.ex
483 rajveer 970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 971 
 
1149 chandransh 972 
  def addBillingDetails(self, orderId, invoice_number, billed_by):
494 rajveer 973 
    """
1149 chandransh 974 
    Add billing details such as the bill number and the biller to the Order.
975 
 
494 rajveer 976 
    Parameters:
977 
     - orderId
978 
     - invoice_number
979 
     - billed_by
980 
    """
1149 chandransh 981 
    self.send_addBillingDetails(orderId, invoice_number, billed_by)
494 rajveer 982 
    return self.recv_addBillingDetails()
983 
 
1149 chandransh 984 
  def send_addBillingDetails(self, orderId, invoice_number, billed_by):
494 rajveer 985 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
986 
    args = addBillingDetails_args()
987 
    args.orderId = orderId
988 
    args.invoice_number = invoice_number
989 
    args.billed_by = billed_by
990 
    args.write(self._oprot)
991 
    self._oprot.writeMessageEnd()
992 
    self._oprot.trans.flush()
993 
 
994 
  def recv_addBillingDetails(self, ):
995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
996 
    if mtype == TMessageType.EXCEPTION:
997 
      x = TApplicationException()
998 
      x.read(self._iprot)
999 
      self._iprot.readMessageEnd()
1000 
      raise x
1001 
    result = addBillingDetails_result()
1002 
    result.read(self._iprot)
1003 
    self._iprot.readMessageEnd()
1004 
    if result.success != None:
1005 
      return result.success
1006 
    if result.ex != None:
1007 
      raise result.ex
1008 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1009 
 
2842 chandransh 1010 
  def addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
1149 chandransh 1011 
    """
2446 chandransh 1012 
    Adds jacket number and IMEI no. to the order. Doesn't update the IMEI no. if a -1 is supplied.
1013 
    Also marks the order as billed and sets the billing timestamp.
1014 
    Return false if it doesn't find the order with the given ID.
1149 chandransh 1015 
 
1016 
    Parameters:
1017 
     - orderId
1018 
     - jacketNumber
2783 chandransh 1019 
     - imeiNumber
1020 
     - itemNumber
1021 
     - billedBy
2842 chandransh 1022 
     - billingType
1149 chandransh 1023 
    """
2842 chandransh 1024 
    self.send_addJacketNumber(orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType)
1149 chandransh 1025 
    return self.recv_addJacketNumber()
1026 
 
2842 chandransh 1027 
  def send_addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
1149 chandransh 1028 
    self._oprot.writeMessageBegin('addJacketNumber', TMessageType.CALL, self._seqid)
1029 
    args = addJacketNumber_args()
1030 
    args.orderId = orderId
1031 
    args.jacketNumber = jacketNumber
2783 chandransh 1032 
    args.imeiNumber = imeiNumber
1033 
    args.itemNumber = itemNumber
1034 
    args.billedBy = billedBy
2842 chandransh 1035 
    args.billingType = billingType
1149 chandransh 1036 
    args.write(self._oprot)
1037 
    self._oprot.writeMessageEnd()
1038 
    self._oprot.trans.flush()
1039 
 
1040 
  def recv_addJacketNumber(self, ):
1041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1042 
    if mtype == TMessageType.EXCEPTION:
1043 
      x = TApplicationException()
1044 
      x.read(self._iprot)
1045 
      self._iprot.readMessageEnd()
1046 
      raise x
1047 
    result = addJacketNumber_result()
1048 
    result.read(self._iprot)
1049 
    self._iprot.readMessageEnd()
1050 
    if result.success != None:
1051 
      return result.success
1052 
    if result.ex != None:
1053 
      raise result.ex
1054 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addJacketNumber failed: unknown result");
1055 
 
921 rajveer 1056 
  def acceptOrder(self, orderId):
1057 
    """
1058 
    Parameters:
1059 
     - orderId
1060 
    """
1061 
    self.send_acceptOrder(orderId)
1062 
    return self.recv_acceptOrder()
1063 
 
1064 
  def send_acceptOrder(self, orderId):
1065 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1066 
    args = acceptOrder_args()
1067 
    args.orderId = orderId
1068 
    args.write(self._oprot)
1069 
    self._oprot.writeMessageEnd()
1070 
    self._oprot.trans.flush()
1071 
 
1072 
  def recv_acceptOrder(self, ):
1073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1074 
    if mtype == TMessageType.EXCEPTION:
1075 
      x = TApplicationException()
1076 
      x.read(self._iprot)
1077 
      self._iprot.readMessageEnd()
1078 
      raise x
1079 
    result = acceptOrder_result()
1080 
    result.read(self._iprot)
1081 
    self._iprot.readMessageEnd()
1082 
    if result.success != None:
1083 
      return result.success
1084 
    if result.ex != None:
1085 
      raise result.ex
1086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1087 
 
1088 
  def billOrder(self, orderId):
1089 
    """
1090 
    Parameters:
1091 
     - orderId
1092 
    """
1093 
    self.send_billOrder(orderId)
1094 
    return self.recv_billOrder()
1095 
 
1096 
  def send_billOrder(self, orderId):
1097 
    self._oprot.writeMessageBegin('billOrder', TMessageType.CALL, self._seqid)
1098 
    args = billOrder_args()
1099 
    args.orderId = orderId
1100 
    args.write(self._oprot)
1101 
    self._oprot.writeMessageEnd()
1102 
    self._oprot.trans.flush()
1103 
 
1104 
  def recv_billOrder(self, ):
1105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1106 
    if mtype == TMessageType.EXCEPTION:
1107 
      x = TApplicationException()
1108 
      x.read(self._iprot)
1109 
      self._iprot.readMessageEnd()
1110 
      raise x
1111 
    result = billOrder_result()
1112 
    result.read(self._iprot)
1113 
    self._iprot.readMessageEnd()
1114 
    if result.success != None:
1115 
      return result.success
1116 
    if result.ex != None:
1117 
      raise result.ex
1118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "billOrder failed: unknown result");
1119 
 
1528 ankur.sing 1120 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1121 
    """
1528 ankur.sing 1122 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1123 
    only user who owns the transaction can view its order details.
1124 
 
94 ashish 1125 
    Parameters:
1126 
     - transactionId
1528 ankur.sing 1127 
     - customerId
94 ashish 1128 
    """
1528 ankur.sing 1129 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1130 
    return self.recv_getOrdersForTransaction()
94 ashish 1131 
 
1528 ankur.sing 1132 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1133 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1134 
    args = getOrdersForTransaction_args()
94 ashish 1135 
    args.transactionId = transactionId
1528 ankur.sing 1136 
    args.customerId = customerId
94 ashish 1137 
    args.write(self._oprot)
1138 
    self._oprot.writeMessageEnd()
1139 
    self._oprot.trans.flush()
1140 
 
483 rajveer 1141 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1143 
    if mtype == TMessageType.EXCEPTION:
1144 
      x = TApplicationException()
1145 
      x.read(self._iprot)
1146 
      self._iprot.readMessageEnd()
1147 
      raise x
483 rajveer 1148 
    result = getOrdersForTransaction_result()
94 ashish 1149 
    result.read(self._iprot)
1150 
    self._iprot.readMessageEnd()
1151 
    if result.success != None:
1152 
      return result.success
1153 
    if result.ex != None:
1154 
      raise result.ex
483 rajveer 1155 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1156 
 
3014 chandransh 1157 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1158 
    """
3014 chandransh 1159 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1160 
    Pass and empty list to ignore filtering on statuses.
1161 
 
94 ashish 1162 
    Parameters:
483 rajveer 1163 
     - customerId
1164 
     - from_date
1165 
     - to_date
3014 chandransh 1166 
     - statuses
94 ashish 1167 
    """
3014 chandransh 1168 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1169 
    return self.recv_getOrdersForCustomer()
94 ashish 1170 
 
3014 chandransh 1171 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1172 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1173 
    args = getOrdersForCustomer_args()
1174 
    args.customerId = customerId
1175 
    args.from_date = from_date
1176 
    args.to_date = to_date
3014 chandransh 1177 
    args.statuses = statuses
94 ashish 1178 
    args.write(self._oprot)
1179 
    self._oprot.writeMessageEnd()
1180 
    self._oprot.trans.flush()
1181 
 
483 rajveer 1182 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1183 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1184 
    if mtype == TMessageType.EXCEPTION:
1185 
      x = TApplicationException()
1186 
      x.read(self._iprot)
1187 
      self._iprot.readMessageEnd()
1188 
      raise x
483 rajveer 1189 
    result = getOrdersForCustomer_result()
94 ashish 1190 
    result.read(self._iprot)
1191 
    self._iprot.readMessageEnd()
1192 
    if result.success != None:
1193 
      return result.success
1194 
    if result.ex != None:
1195 
      raise result.ex
483 rajveer 1196 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1197 
 
483 rajveer 1198 
  def createOrder(self, order):
94 ashish 1199 
    """
1200 
    Parameters:
483 rajveer 1201 
     - order
94 ashish 1202 
    """
483 rajveer 1203 
    self.send_createOrder(order)
1204 
    return self.recv_createOrder()
94 ashish 1205 
 
483 rajveer 1206 
  def send_createOrder(self, order):
1207 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1208 
    args = createOrder_args()
1209 
    args.order = order
94 ashish 1210 
    args.write(self._oprot)
1211 
    self._oprot.writeMessageEnd()
1212 
    self._oprot.trans.flush()
1213 
 
483 rajveer 1214 
  def recv_createOrder(self, ):
94 ashish 1215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1216 
    if mtype == TMessageType.EXCEPTION:
1217 
      x = TApplicationException()
1218 
      x.read(self._iprot)
1219 
      self._iprot.readMessageEnd()
1220 
      raise x
483 rajveer 1221 
    result = createOrder_result()
94 ashish 1222 
    result.read(self._iprot)
1223 
    self._iprot.readMessageEnd()
1224 
    if result.success != None:
1225 
      return result.success
1226 
    if result.ex != None:
1227 
      raise result.ex
483 rajveer 1228 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1229 
 
483 rajveer 1230 
  def getOrder(self, id):
94 ashish 1231 
    """
1232 
    Parameters:
483 rajveer 1233 
     - id
94 ashish 1234 
    """
483 rajveer 1235 
    self.send_getOrder(id)
1236 
    return self.recv_getOrder()
94 ashish 1237 
 
483 rajveer 1238 
  def send_getOrder(self, id):
1239 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1240 
    args = getOrder_args()
1241 
    args.id = id
94 ashish 1242 
    args.write(self._oprot)
1243 
    self._oprot.writeMessageEnd()
1244 
    self._oprot.trans.flush()
1245 
 
483 rajveer 1246 
  def recv_getOrder(self, ):
94 ashish 1247 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1248 
    if mtype == TMessageType.EXCEPTION:
1249 
      x = TApplicationException()
1250 
      x.read(self._iprot)
1251 
      self._iprot.readMessageEnd()
1252 
      raise x
483 rajveer 1253 
    result = getOrder_result()
94 ashish 1254 
    result.read(self._iprot)
1255 
    self._iprot.readMessageEnd()
1256 
    if result.success != None:
1257 
      return result.success
1258 
    if result.ex != None:
1259 
      raise result.ex
483 rajveer 1260 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1261 
 
483 rajveer 1262 
  def getLineItemsForOrder(self, orderId):
94 ashish 1263 
    """
1264 
    Parameters:
483 rajveer 1265 
     - orderId
94 ashish 1266 
    """
483 rajveer 1267 
    self.send_getLineItemsForOrder(orderId)
1268 
    return self.recv_getLineItemsForOrder()
94 ashish 1269 
 
483 rajveer 1270 
  def send_getLineItemsForOrder(self, orderId):
1271 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1272 
    args = getLineItemsForOrder_args()
1273 
    args.orderId = orderId
94 ashish 1274 
    args.write(self._oprot)
1275 
    self._oprot.writeMessageEnd()
1276 
    self._oprot.trans.flush()
1277 
 
483 rajveer 1278 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1279 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1280 
    if mtype == TMessageType.EXCEPTION:
1281 
      x = TApplicationException()
1282 
      x.read(self._iprot)
1283 
      self._iprot.readMessageEnd()
1284 
      raise x
483 rajveer 1285 
    result = getLineItemsForOrder_result()
94 ashish 1286 
    result.read(self._iprot)
1287 
    self._iprot.readMessageEnd()
1288 
    if result.success != None:
1289 
      return result.success
1290 
    if result.ex != None:
1291 
      raise result.ex
483 rajveer 1292 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1293 
 
1528 ankur.sing 1294 
  def getOrderForCustomer(self, orderId, customerId):
1295 
    """
1296 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1297 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
1298 
 
1299 
    Parameters:
1300 
     - orderId
1301 
     - customerId
1302 
    """
1303 
    self.send_getOrderForCustomer(orderId, customerId)
1304 
    return self.recv_getOrderForCustomer()
1305 
 
1306 
  def send_getOrderForCustomer(self, orderId, customerId):
1307 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1308 
    args = getOrderForCustomer_args()
1309 
    args.orderId = orderId
1310 
    args.customerId = customerId
1311 
    args.write(self._oprot)
1312 
    self._oprot.writeMessageEnd()
1313 
    self._oprot.trans.flush()
1314 
 
1315 
  def recv_getOrderForCustomer(self, ):
1316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1317 
    if mtype == TMessageType.EXCEPTION:
1318 
      x = TApplicationException()
1319 
      x.read(self._iprot)
1320 
      self._iprot.readMessageEnd()
1321 
      raise x
1322 
    result = getOrderForCustomer_result()
1323 
    result.read(self._iprot)
1324 
    self._iprot.readMessageEnd()
1325 
    if result.success != None:
1326 
      return result.success
1327 
    if result.ex != None:
1328 
      raise result.ex
1329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1330 
 
1220 chandransh 1331 
  def batchOrders(self, warehouseId):
1332 
    """
1333 
    Create a batch of all the pending orders for the given warehouse.
1334 
    The returned list is orderd by created_timestamp.
1335 
    If there are no pending orders, an empty list is returned.
1336 
 
1337 
    Parameters:
1338 
     - warehouseId
1339 
    """
1340 
    self.send_batchOrders(warehouseId)
1341 
    return self.recv_batchOrders()
1342 
 
1343 
  def send_batchOrders(self, warehouseId):
1344 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1345 
    args = batchOrders_args()
1346 
    args.warehouseId = warehouseId
1347 
    args.write(self._oprot)
1348 
    self._oprot.writeMessageEnd()
1349 
    self._oprot.trans.flush()
1350 
 
1351 
  def recv_batchOrders(self, ):
1352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1353 
    if mtype == TMessageType.EXCEPTION:
1354 
      x = TApplicationException()
1355 
      x.read(self._iprot)
1356 
      self._iprot.readMessageEnd()
1357 
      raise x
1358 
    result = batchOrders_result()
1359 
    result.read(self._iprot)
1360 
    self._iprot.readMessageEnd()
1361 
    if result.success != None:
1362 
      return result.success
1363 
    if result.ex != None:
1364 
      raise result.ex
1365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1366 
 
1208 chandransh 1367 
  def markOrderAsOutOfStock(self, orderId):
1368 
    """
1369 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
1370 
 
1371 
    Parameters:
1372 
     - orderId
1373 
    """
1374 
    self.send_markOrderAsOutOfStock(orderId)
1375 
    return self.recv_markOrderAsOutOfStock()
1376 
 
1377 
  def send_markOrderAsOutOfStock(self, orderId):
1378 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1379 
    args = markOrderAsOutOfStock_args()
1380 
    args.orderId = orderId
1381 
    args.write(self._oprot)
1382 
    self._oprot.writeMessageEnd()
1383 
    self._oprot.trans.flush()
1384 
 
1385 
  def recv_markOrderAsOutOfStock(self, ):
1386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1387 
    if mtype == TMessageType.EXCEPTION:
1388 
      x = TApplicationException()
1389 
      x.read(self._iprot)
1390 
      self._iprot.readMessageEnd()
1391 
      raise x
1392 
    result = markOrderAsOutOfStock_result()
1393 
    result.read(self._iprot)
1394 
    self._iprot.readMessageEnd()
1395 
    if result.success != None:
1396 
      return result.success
1397 
    if result.ex != None:
1398 
      raise result.ex
1399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1400 
 
759 chandransh 1401 
  def markOrdersAsManifested(self, warehouseId, providerId):
1402 
    """
1403 
    Marks all BILLED orders for a warehouse and a provider as SHIPPED_FROM_WH
1404 
 
1405 
    Parameters:
1406 
     - warehouseId
1407 
     - providerId
1408 
    """
1409 
    self.send_markOrdersAsManifested(warehouseId, providerId)
1410 
    return self.recv_markOrdersAsManifested()
1411 
 
1412 
  def send_markOrdersAsManifested(self, warehouseId, providerId):
1413 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1414 
    args = markOrdersAsManifested_args()
1415 
    args.warehouseId = warehouseId
1416 
    args.providerId = providerId
1417 
    args.write(self._oprot)
1418 
    self._oprot.writeMessageEnd()
1419 
    self._oprot.trans.flush()
1420 
 
1421 
  def recv_markOrdersAsManifested(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 = markOrdersAsManifested_result()
1429 
    result.read(self._iprot)
1430 
    self._iprot.readMessageEnd()
1431 
    if result.success != None:
1432 
      return result.success
1433 
    if result.ex != None:
1434 
      raise result.ex
1435 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1436 
 
1113 chandransh 1437 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
1438 
    """
1439 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
1440 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
1441 
    Raises an exception if we encounter report for an AWB number that we did not ship.
1442 
 
1443 
    Parameters:
1444 
     - providerId
1445 
     - pickupDetails
1446 
    """
1447 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
1448 
    return self.recv_markOrdersAsPickedUp()
1449 
 
1450 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
1451 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
1452 
    args = markOrdersAsPickedUp_args()
1453 
    args.providerId = providerId
1454 
    args.pickupDetails = pickupDetails
1455 
    args.write(self._oprot)
1456 
    self._oprot.writeMessageEnd()
1457 
    self._oprot.trans.flush()
1458 
 
1459 
  def recv_markOrdersAsPickedUp(self, ):
1460 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1461 
    if mtype == TMessageType.EXCEPTION:
1462 
      x = TApplicationException()
1463 
      x.read(self._iprot)
1464 
      self._iprot.readMessageEnd()
1465 
      raise x
1466 
    result = markOrdersAsPickedUp_result()
1467 
    result.read(self._iprot)
1468 
    self._iprot.readMessageEnd()
1469 
    if result.success != None:
1470 
      return result.success
1471 
    if result.ex != None:
1472 
      raise result.ex
1473 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
1474 
 
1132 chandransh 1475 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
1476 
    """
1477 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
1478 
    the name of the receiver.
1479 
    Raises an exception if we encounter report for an AWB number that we did not ship.
1480 
 
1481 
    Parameters:
1482 
     - providerId
1483 
     - deliveredOrders
1484 
    """
1485 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
1486 
    self.recv_markOrdersAsDelivered()
1487 
 
1488 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
1489 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
1490 
    args = markOrdersAsDelivered_args()
1491 
    args.providerId = providerId
1492 
    args.deliveredOrders = deliveredOrders
1493 
    args.write(self._oprot)
1494 
    self._oprot.writeMessageEnd()
1495 
    self._oprot.trans.flush()
1496 
 
1497 
  def recv_markOrdersAsDelivered(self, ):
1498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1499 
    if mtype == TMessageType.EXCEPTION:
1500 
      x = TApplicationException()
1501 
      x.read(self._iprot)
1502 
      self._iprot.readMessageEnd()
1503 
      raise x
1504 
    result = markOrdersAsDelivered_result()
1505 
    result.read(self._iprot)
1506 
    self._iprot.readMessageEnd()
1507 
    if result.ex != None:
1508 
      raise result.ex
1509 
    return
1510 
 
1135 chandransh 1511 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1512 
    """
1513 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
1514 
    Raises an exception if we encounter report for an AWB number that we did not ship.
1515 
 
1516 
    Parameters:
1517 
     - providerId
1518 
     - returnedOrders
1519 
    """
1520 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
1521 
    self.recv_markOrdersAsFailed()
1522 
 
1523 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
1524 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
1525 
    args = markOrdersAsFailed_args()
1526 
    args.providerId = providerId
1527 
    args.returnedOrders = returnedOrders
1528 
    args.write(self._oprot)
1529 
    self._oprot.writeMessageEnd()
1530 
    self._oprot.trans.flush()
1531 
 
1532 
  def recv_markOrdersAsFailed(self, ):
1533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1534 
    if mtype == TMessageType.EXCEPTION:
1535 
      x = TApplicationException()
1536 
      x.read(self._iprot)
1537 
      self._iprot.readMessageEnd()
1538 
      raise x
1539 
    result = markOrdersAsFailed_result()
1540 
    result.read(self._iprot)
1541 
    self._iprot.readMessageEnd()
1542 
    if result.ex != None:
1543 
      raise result.ex
1544 
    return
1545 
 
1246 chandransh 1546 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1547 
    """
1548 
    Update the status description of orders whose AWB numbers are keys of the Map.
1549 
 
1550 
    Parameters:
1551 
     - providerId
1552 
     - undeliveredOrders
1553 
    """
1554 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
1555 
    self.recv_updateNonDeliveryReason()
1556 
 
1557 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
1558 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
1559 
    args = updateNonDeliveryReason_args()
1560 
    args.providerId = providerId
1561 
    args.undeliveredOrders = undeliveredOrders
1562 
    args.write(self._oprot)
1563 
    self._oprot.writeMessageEnd()
1564 
    self._oprot.trans.flush()
1565 
 
1566 
  def recv_updateNonDeliveryReason(self, ):
1567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1568 
    if mtype == TMessageType.EXCEPTION:
1569 
      x = TApplicationException()
1570 
      x.read(self._iprot)
1571 
      self._iprot.readMessageEnd()
1572 
      raise x
1573 
    result = updateNonDeliveryReason_result()
1574 
    result.read(self._iprot)
1575 
    self._iprot.readMessageEnd()
1576 
    if result.ex != None:
1577 
      raise result.ex
1578 
    return
1579 
 
1408 ankur.sing 1580 
  def getUndeliveredOrders(self, providerId, warehouseId):
1581 
    """
1582 
    Returns the list of orders whose delivery time has passed but have not been
1583 
    delivered yet for the given provider and warehouse. To get a complete list of
1584 
    undelivered orders, pass them as -1.
1585 
    Returns an empty list if no such orders exist.
1586 
 
1587 
    Parameters:
1588 
     - providerId
1589 
     - warehouseId
1590 
    """
1591 
    self.send_getUndeliveredOrders(providerId, warehouseId)
1592 
    return self.recv_getUndeliveredOrders()
1593 
 
1594 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
1595 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
1596 
    args = getUndeliveredOrders_args()
1597 
    args.providerId = providerId
1598 
    args.warehouseId = warehouseId
1599 
    args.write(self._oprot)
1600 
    self._oprot.writeMessageEnd()
1601 
    self._oprot.trans.flush()
1602 
 
1603 
  def recv_getUndeliveredOrders(self, ):
1604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1605 
    if mtype == TMessageType.EXCEPTION:
1606 
      x = TApplicationException()
1607 
      x.read(self._iprot)
1608 
      self._iprot.readMessageEnd()
1609 
      raise x
1610 
    result = getUndeliveredOrders_result()
1611 
    result.read(self._iprot)
1612 
    self._iprot.readMessageEnd()
1613 
    if result.success != None:
1614 
      return result.success
1615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1616 
 
483 rajveer 1617 
  def getAlerts(self, orderId, valid):
94 ashish 1618 
    """
1619 
    Parameters:
483 rajveer 1620 
     - orderId
304 ashish 1621 
     - valid
1622 
    """
483 rajveer 1623 
    self.send_getAlerts(orderId, valid)
304 ashish 1624 
    return self.recv_getAlerts()
94 ashish 1625 
 
483 rajveer 1626 
  def send_getAlerts(self, orderId, valid):
304 ashish 1627 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1628 
    args = getAlerts_args()
483 rajveer 1629 
    args.orderId = orderId
304 ashish 1630 
    args.valid = valid
1631 
    args.write(self._oprot)
1632 
    self._oprot.writeMessageEnd()
1633 
    self._oprot.trans.flush()
1634 
 
1635 
  def recv_getAlerts(self, ):
1636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1637 
    if mtype == TMessageType.EXCEPTION:
1638 
      x = TApplicationException()
1639 
      x.read(self._iprot)
1640 
      self._iprot.readMessageEnd()
1641 
      raise x
1642 
    result = getAlerts_result()
1643 
    result.read(self._iprot)
1644 
    self._iprot.readMessageEnd()
1645 
    if result.success != None:
1646 
      return result.success
1647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1648 
 
483 rajveer 1649 
  def setAlert(self, orderId, unset, type, comment):
304 ashish 1650 
    """
1651 
    Parameters:
483 rajveer 1652 
     - orderId
304 ashish 1653 
     - unset
1654 
     - type
1655 
     - comment
1656 
    """
483 rajveer 1657 
    self.send_setAlert(orderId, unset, type, comment)
304 ashish 1658 
    self.recv_setAlert()
1659 
 
483 rajveer 1660 
  def send_setAlert(self, orderId, unset, type, comment):
304 ashish 1661 
    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
1662 
    args = setAlert_args()
483 rajveer 1663 
    args.orderId = orderId
304 ashish 1664 
    args.unset = unset
1665 
    args.type = type
1666 
    args.comment = comment
1667 
    args.write(self._oprot)
1668 
    self._oprot.writeMessageEnd()
1669 
    self._oprot.trans.flush()
1670 
 
1671 
  def recv_setAlert(self, ):
1672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1673 
    if mtype == TMessageType.EXCEPTION:
1674 
      x = TApplicationException()
1675 
      x.read(self._iprot)
1676 
      self._iprot.readMessageEnd()
1677 
      raise x
1678 
    result = setAlert_result()
1679 
    result.read(self._iprot)
1680 
    self._iprot.readMessageEnd()
1681 
    return
1682 
 
1596 ankur.sing 1683 
  def getValidOrderCount(self, ):
1684 
    """
1685 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1686 
    """
1687 
    self.send_getValidOrderCount()
1688 
    return self.recv_getValidOrderCount()
304 ashish 1689 
 
1596 ankur.sing 1690 
  def send_getValidOrderCount(self, ):
1691 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1692 
    args = getValidOrderCount_args()
1693 
    args.write(self._oprot)
1694 
    self._oprot.writeMessageEnd()
1695 
    self._oprot.trans.flush()
1696 
 
1697 
  def recv_getValidOrderCount(self, ):
1698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1699 
    if mtype == TMessageType.EXCEPTION:
1700 
      x = TApplicationException()
1701 
      x.read(self._iprot)
1702 
      self._iprot.readMessageEnd()
1703 
      raise x
1704 
    result = getValidOrderCount_result()
1705 
    result.read(self._iprot)
1706 
    self._iprot.readMessageEnd()
1707 
    if result.success != None:
1708 
      return result.success
1709 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1710 
 
1627 ankur.sing 1711 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1712 
    """
1713 
    Returns the number of distinct customers who have done successful transactions
1714 
    """
1715 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1716 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1596 ankur.sing 1717 
 
1627 ankur.sing 1718 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1719 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1720 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1721 
    args.write(self._oprot)
1722 
    self._oprot.writeMessageEnd()
1723 
    self._oprot.trans.flush()
1724 
 
1725 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1726 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1727 
    if mtype == TMessageType.EXCEPTION:
1728 
      x = TApplicationException()
1729 
      x.read(self._iprot)
1730 
      self._iprot.readMessageEnd()
1731 
      raise x
1732 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1733 
    result.read(self._iprot)
1734 
    self._iprot.readMessageEnd()
1735 
    if result.success != None:
1736 
      return result.success
1737 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1738 
 
1731 ankur.sing 1739 
  def getValidOrdersAmountRange(self, ):
1627 ankur.sing 1740 
    """
1731 ankur.sing 1741 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1742 
    List contains two values, first minimum amount and second maximum amount.
1627 ankur.sing 1743 
    """
1731 ankur.sing 1744 
    self.send_getValidOrdersAmountRange()
1745 
    return self.recv_getValidOrdersAmountRange()
1627 ankur.sing 1746 
 
1731 ankur.sing 1747 
  def send_getValidOrdersAmountRange(self, ):
1748 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1749 
    args = getValidOrdersAmountRange_args()
1627 ankur.sing 1750 
    args.write(self._oprot)
1751 
    self._oprot.writeMessageEnd()
1752 
    self._oprot.trans.flush()
1753 
 
1731 ankur.sing 1754 
  def recv_getValidOrdersAmountRange(self, ):
1627 ankur.sing 1755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1756 
    if mtype == TMessageType.EXCEPTION:
1757 
      x = TApplicationException()
1758 
      x.read(self._iprot)
1759 
      self._iprot.readMessageEnd()
1760 
      raise x
1731 ankur.sing 1761 
    result = getValidOrdersAmountRange_result()
1627 ankur.sing 1762 
    result.read(self._iprot)
1763 
    self._iprot.readMessageEnd()
1764 
    if result.success != None:
1765 
      return result.success
1731 ankur.sing 1766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1627 ankur.sing 1767 
 
1886 ankur.sing 1768 
  def getValidOrders(self, limit):
1769 
    """
1770 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1771 
    If limit is passed as 0, then all valid Orders are returned.
1772 
 
1773 
    Parameters:
1774 
     - limit
1775 
    """
1776 
    self.send_getValidOrders(limit)
1777 
    return self.recv_getValidOrders()
1627 ankur.sing 1778 
 
1886 ankur.sing 1779 
  def send_getValidOrders(self, limit):
1780 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1781 
    args = getValidOrders_args()
1782 
    args.limit = limit
1783 
    args.write(self._oprot)
1784 
    self._oprot.writeMessageEnd()
1785 
    self._oprot.trans.flush()
1786 
 
1787 
  def recv_getValidOrders(self, ):
1788 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1789 
    if mtype == TMessageType.EXCEPTION:
1790 
      x = TApplicationException()
1791 
      x.read(self._iprot)
1792 
      self._iprot.readMessageEnd()
1793 
      raise x
1794 
    result = getValidOrders_result()
1795 
    result.read(self._iprot)
1796 
    self._iprot.readMessageEnd()
1797 
    if result.success != None:
1798 
      return result.success
1799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1800 
 
2536 chandransh 1801 
  def toggleDOAFlag(self, orderId):
1802 
    """
1803 
    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.
1804 
    Returns the final flag status.
1805 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
1806 
 
1807 
    Parameters:
1808 
     - orderId
1809 
    """
1810 
    self.send_toggleDOAFlag(orderId)
1811 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 1812 
 
2536 chandransh 1813 
  def send_toggleDOAFlag(self, orderId):
1814 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
1815 
    args = toggleDOAFlag_args()
1816 
    args.orderId = orderId
1817 
    args.write(self._oprot)
1818 
    self._oprot.writeMessageEnd()
1819 
    self._oprot.trans.flush()
1820 
 
1821 
  def recv_toggleDOAFlag(self, ):
1822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1823 
    if mtype == TMessageType.EXCEPTION:
1824 
      x = TApplicationException()
1825 
      x.read(self._iprot)
1826 
      self._iprot.readMessageEnd()
1827 
      raise x
1828 
    result = toggleDOAFlag_result()
1829 
    result.read(self._iprot)
1830 
    self._iprot.readMessageEnd()
1831 
    if result.success != None:
1832 
      return result.success
1833 
    if result.ex != None:
1834 
      raise result.ex
1835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
1836 
 
1837 
  def requestPickupNumber(self, orderId):
1838 
    """
1839 
    Sends out an email to the account manager of the original courier provider used to ship the order.
1840 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
1841 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
1842 
    For any other status, it returns false.
1843 
    Throws an exception if the order with the given id couldn't be found.
1844 
 
1845 
    Parameters:
1846 
     - orderId
1847 
    """
1848 
    self.send_requestPickupNumber(orderId)
1849 
    return self.recv_requestPickupNumber()
1850 
 
1851 
  def send_requestPickupNumber(self, orderId):
1852 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
1853 
    args = requestPickupNumber_args()
1854 
    args.orderId = orderId
1855 
    args.write(self._oprot)
1856 
    self._oprot.writeMessageEnd()
1857 
    self._oprot.trans.flush()
1858 
 
1859 
  def recv_requestPickupNumber(self, ):
1860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1861 
    if mtype == TMessageType.EXCEPTION:
1862 
      x = TApplicationException()
1863 
      x.read(self._iprot)
1864 
      self._iprot.readMessageEnd()
1865 
      raise x
1866 
    result = requestPickupNumber_result()
1867 
    result.read(self._iprot)
1868 
    self._iprot.readMessageEnd()
1869 
    if result.success != None:
1870 
      return result.success
1871 
    if result.ex != None:
1872 
      raise result.ex
1873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
1874 
 
1875 
  def authorizePickup(self, orderId, pickupNumber):
1876 
    """
1877 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
1878 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
1879 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
1880 
    	3. Returns true
2591 chandransh 1881 
    If the order is in any other status, it returns false.
2536 chandransh 1882 
    Throws an exception if the order with the given id couldn't be found.
1883 
 
1884 
    Parameters:
1885 
     - orderId
1886 
     - pickupNumber
1887 
    """
1888 
    self.send_authorizePickup(orderId, pickupNumber)
1889 
    return self.recv_authorizePickup()
1890 
 
1891 
  def send_authorizePickup(self, orderId, pickupNumber):
1892 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
1893 
    args = authorizePickup_args()
1894 
    args.orderId = orderId
1895 
    args.pickupNumber = pickupNumber
1896 
    args.write(self._oprot)
1897 
    self._oprot.writeMessageEnd()
1898 
    self._oprot.trans.flush()
1899 
 
1900 
  def recv_authorizePickup(self, ):
1901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1902 
    if mtype == TMessageType.EXCEPTION:
1903 
      x = TApplicationException()
1904 
      x.read(self._iprot)
1905 
      self._iprot.readMessageEnd()
1906 
      raise x
1907 
    result = authorizePickup_result()
1908 
    result.read(self._iprot)
1909 
    self._iprot.readMessageEnd()
1910 
    if result.success != None:
1911 
      return result.success
1912 
    if result.ex != None:
1913 
      raise result.ex
1914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
1915 
 
2764 chandransh 1916 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
1917 
    """
1918 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
1919 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
1920 
 
1921 
    Parameters:
1922 
     - providerId
1923 
     - pickupDetails
1924 
    """
1925 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
1926 
    return self.recv_markDoasAsPickedUp()
1927 
 
1928 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
1929 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
1930 
    args = markDoasAsPickedUp_args()
1931 
    args.providerId = providerId
1932 
    args.pickupDetails = pickupDetails
1933 
    args.write(self._oprot)
1934 
    self._oprot.writeMessageEnd()
1935 
    self._oprot.trans.flush()
1936 
 
1937 
  def recv_markDoasAsPickedUp(self, ):
1938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1939 
    if mtype == TMessageType.EXCEPTION:
1940 
      x = TApplicationException()
1941 
      x.read(self._iprot)
1942 
      self._iprot.readMessageEnd()
1943 
      raise x
1944 
    result = markDoasAsPickedUp_result()
1945 
    result.read(self._iprot)
1946 
    self._iprot.readMessageEnd()
1947 
    if result.success != None:
1948 
      return result.success
1949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
1950 
 
2616 chandransh 1951 
  def receiveReturn(self, orderId):
2591 chandransh 1952 
    """
2599 chandransh 1953 
    If the order status is DOA_RETURN_AUTHORIZED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED and returns true.
2616 chandransh 1954 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 1955 
    If the order is in any other state, it returns false.
1956 
    Throws an exception if the order with the given id couldn't be found.
1957 
 
1958 
    Parameters:
1959 
     - orderId
1960 
    """
2616 chandransh 1961 
    self.send_receiveReturn(orderId)
1962 
    return self.recv_receiveReturn()
2536 chandransh 1963 
 
2616 chandransh 1964 
  def send_receiveReturn(self, orderId):
1965 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
1966 
    args = receiveReturn_args()
2591 chandransh 1967 
    args.orderId = orderId
1968 
    args.write(self._oprot)
1969 
    self._oprot.writeMessageEnd()
1970 
    self._oprot.trans.flush()
1971 
 
2616 chandransh 1972 
  def recv_receiveReturn(self, ):
2591 chandransh 1973 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1974 
    if mtype == TMessageType.EXCEPTION:
1975 
      x = TApplicationException()
1976 
      x.read(self._iprot)
1977 
      self._iprot.readMessageEnd()
1978 
      raise x
2616 chandransh 1979 
    result = receiveReturn_result()
2591 chandransh 1980 
    result.read(self._iprot)
1981 
    self._iprot.readMessageEnd()
1982 
    if result.success != None:
1983 
      return result.success
1984 
    if result.ex != None:
1985 
      raise result.ex
2616 chandransh 1986 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 1987 
 
1988 
  def validateDoa(self, orderId, isValid):
1989 
    """
2599 chandransh 1990 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 1991 
    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 1992 
    If the order is in any other state, it returns false.
1993 
    Throws an exception if the order with the given id couldn't be found.
1994 
 
1995 
    Parameters:
1996 
     - orderId
1997 
     - isValid
1998 
    """
1999 
    self.send_validateDoa(orderId, isValid)
2000 
    return self.recv_validateDoa()
2001 
 
2002 
  def send_validateDoa(self, orderId, isValid):
2003 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
2004 
    args = validateDoa_args()
2005 
    args.orderId = orderId
2006 
    args.isValid = isValid
2007 
    args.write(self._oprot)
2008 
    self._oprot.writeMessageEnd()
2009 
    self._oprot.trans.flush()
2010 
 
2011 
  def recv_validateDoa(self, ):
2012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2013 
    if mtype == TMessageType.EXCEPTION:
2014 
      x = TApplicationException()
2015 
      x.read(self._iprot)
2016 
      self._iprot.readMessageEnd()
2017 
      raise x
2018 
    result = validateDoa_result()
2019 
    result.read(self._iprot)
2020 
    self._iprot.readMessageEnd()
2021 
    if result.success != None:
2022 
      return result.success
2023 
    if result.ex != None:
2024 
      raise result.ex
2025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
2026 
 
2616 chandransh 2027 
  def reshipOrder(self, orderId):
2028 
    """
2029 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
2030 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
2031 
    	2. Marks the current order as one of the final states SALES_RET_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2032 
 
2033 
    If the order is in DOA_CERT_VALID state, it does the following:
2034 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
2035 
    	2. Creates a return order for the warehouse executive to return the DOA material.
2036 
    	3. Marks the current order as the final DOA_RESHIPPED state.
2037 
 
2038 
    Returns the id of the newly created order.
2039 
 
2040 
    Throws an exception if the order with the given id couldn't be found.
2041 
 
2042 
    Parameters:
2043 
     - orderId
2044 
    """
2045 
    self.send_reshipOrder(orderId)
2046 
    return self.recv_reshipOrder()
2591 chandransh 2047 
 
2616 chandransh 2048 
  def send_reshipOrder(self, orderId):
2049 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
2050 
    args = reshipOrder_args()
2051 
    args.orderId = orderId
2052 
    args.write(self._oprot)
2053 
    self._oprot.writeMessageEnd()
2054 
    self._oprot.trans.flush()
2055 
 
2056 
  def recv_reshipOrder(self, ):
2057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2058 
    if mtype == TMessageType.EXCEPTION:
2059 
      x = TApplicationException()
2060 
      x.read(self._iprot)
2061 
      self._iprot.readMessageEnd()
2062 
      raise x
2063 
    result = reshipOrder_result()
2064 
    result.read(self._iprot)
2065 
    self._iprot.readMessageEnd()
2066 
    if result.success != None:
2067 
      return result.success
2068 
    if result.ex != None:
2069 
      raise result.ex
2070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
2071 
 
2072 
  def refundOrder(self, orderId):
2073 
    """
2074 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2075 
    	1. Creates a refund request for batch processing.
2076 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2077 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
2078 
 
2079 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2080 
    	1. Creates a refund request for batch processing.
2081 
    	2. Marks the current order as the REFUNDED final state.
2082 
 
2083 
    Returns True if it is successful, False otherwise.
2084 
 
2085 
    Throws an exception if the order with the given id couldn't be found.
2086 
 
2087 
    Parameters:
2088 
     - orderId
2089 
    """
2090 
    self.send_refundOrder(orderId)
2091 
    return self.recv_refundOrder()
2092 
 
2093 
  def send_refundOrder(self, orderId):
2094 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2095 
    args = refundOrder_args()
2096 
    args.orderId = orderId
2097 
    args.write(self._oprot)
2098 
    self._oprot.writeMessageEnd()
2099 
    self._oprot.trans.flush()
2100 
 
2101 
  def recv_refundOrder(self, ):
2102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2103 
    if mtype == TMessageType.EXCEPTION:
2104 
      x = TApplicationException()
2105 
      x.read(self._iprot)
2106 
      self._iprot.readMessageEnd()
2107 
      raise x
2108 
    result = refundOrder_result()
2109 
    result.read(self._iprot)
2110 
    self._iprot.readMessageEnd()
2111 
    if result.success != None:
2112 
      return result.success
2113 
    if result.ex != None:
2114 
      raise result.ex
2115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2116 
 
2690 chandransh 2117 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2118 
    """
2119 
    Get all return orders created between the from and to dates for the given warehouse.
2120 
    Ignores the warehouse if it is passed as -1.
2121 
 
2122 
    Parameters:
2123 
     - warehouseId
2124 
     - fromDate
2125 
     - toDate
2126 
    """
2127 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2128 
    return self.recv_getReturnOrders()
2616 chandransh 2129 
 
2690 chandransh 2130 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2131 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2132 
    args = getReturnOrders_args()
2133 
    args.warehouseId = warehouseId
2134 
    args.fromDate = fromDate
2135 
    args.toDate = toDate
2136 
    args.write(self._oprot)
2137 
    self._oprot.writeMessageEnd()
2138 
    self._oprot.trans.flush()
2139 
 
2140 
  def recv_getReturnOrders(self, ):
2141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2142 
    if mtype == TMessageType.EXCEPTION:
2143 
      x = TApplicationException()
2144 
      x.read(self._iprot)
2145 
      self._iprot.readMessageEnd()
2146 
      raise x
2147 
    result = getReturnOrders_result()
2148 
    result.read(self._iprot)
2149 
    self._iprot.readMessageEnd()
2150 
    if result.success != None:
2151 
      return result.success
2152 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2153 
 
2700 chandransh 2154 
  def getReturnOrder(self, id):
2155 
    """
2156 
    Returns the ReturnOrder corresponding to the given id.
2157 
    Throws an exception if the return order with the given id couldn't be found.
2158 
 
2159 
    Parameters:
2160 
     - id
2161 
    """
2162 
    self.send_getReturnOrder(id)
2163 
    return self.recv_getReturnOrder()
2164 
 
2165 
  def send_getReturnOrder(self, id):
2166 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2167 
    args = getReturnOrder_args()
2168 
    args.id = id
2169 
    args.write(self._oprot)
2170 
    self._oprot.writeMessageEnd()
2171 
    self._oprot.trans.flush()
2172 
 
2173 
  def recv_getReturnOrder(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 = getReturnOrder_result()
2181 
    result.read(self._iprot)
2182 
    self._iprot.readMessageEnd()
2183 
    if result.success != None:
2184 
      return result.success
2185 
    if result.ex != None:
2186 
      raise result.ex
2187 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2188 
 
2690 chandransh 2189 
  def processReturn(self, returnOrderId):
2190 
    """
2191 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
2192 
 
2193 
    Parameters:
2194 
     - returnOrderId
2195 
    """
2196 
    self.send_processReturn(returnOrderId)
2197 
    self.recv_processReturn()
2198 
 
2199 
  def send_processReturn(self, returnOrderId):
2200 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2201 
    args = processReturn_args()
2202 
    args.returnOrderId = returnOrderId
2203 
    args.write(self._oprot)
2204 
    self._oprot.writeMessageEnd()
2205 
    self._oprot.trans.flush()
2206 
 
2207 
  def recv_processReturn(self, ):
2208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2209 
    if mtype == TMessageType.EXCEPTION:
2210 
      x = TApplicationException()
2211 
      x.read(self._iprot)
2212 
      self._iprot.readMessageEnd()
2213 
      raise x
2214 
    result = processReturn_result()
2215 
    result.read(self._iprot)
2216 
    self._iprot.readMessageEnd()
2217 
    if result.ex != None:
2218 
      raise result.ex
2219 
    return
2220 
 
2819 chandransh 2221 
  def createPurchaseOrder(self, warehouseId):
2222 
    """
2223 
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
2842 chandransh 2224 
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
2819 chandransh 2225 
 
2226 
    Parameters:
2227 
     - warehouseId
2228 
    """
2229 
    self.send_createPurchaseOrder(warehouseId)
2230 
    return self.recv_createPurchaseOrder()
2690 chandransh 2231 
 
2819 chandransh 2232 
  def send_createPurchaseOrder(self, warehouseId):
2233 
    self._oprot.writeMessageBegin('createPurchaseOrder', TMessageType.CALL, self._seqid)
2234 
    args = createPurchaseOrder_args()
2235 
    args.warehouseId = warehouseId
2236 
    args.write(self._oprot)
2237 
    self._oprot.writeMessageEnd()
2238 
    self._oprot.trans.flush()
2239 
 
2240 
  def recv_createPurchaseOrder(self, ):
2241 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2242 
    if mtype == TMessageType.EXCEPTION:
2243 
      x = TApplicationException()
2244 
      x.read(self._iprot)
2245 
      self._iprot.readMessageEnd()
2246 
      raise x
2247 
    result = createPurchaseOrder_result()
2248 
    result.read(self._iprot)
2249 
    self._iprot.readMessageEnd()
2250 
    if result.success != None:
2251 
      return result.success
2252 
    if result.ex != None:
2253 
      raise result.ex
2254 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
2255 
 
2256 
 
94 ashish 2257 
class Processor(Iface, TProcessor):
2258 
  def __init__(self, handler):
2259 
    self._handler = handler
2260 
    self._processMap = {}
765 rajveer 2261 
    self._processMap["closeSession"] = Processor.process_closeSession
94 ashish 2262 
    self._processMap["createTransaction"] = Processor.process_createTransaction
2263 
    self._processMap["getTransaction"] = Processor.process_getTransaction
2264 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 2265 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 2266 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
2267 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 2268 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 2269 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
999 varun.gupt 2270 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
1382 varun.gupt 2271 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
2272 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 2273 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
494 rajveer 2274 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
1149 chandransh 2275 
    self._processMap["addJacketNumber"] = Processor.process_addJacketNumber
921 rajveer 2276 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
2277 
    self._processMap["billOrder"] = Processor.process_billOrder
483 rajveer 2278 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
2279 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
2280 
    self._processMap["createOrder"] = Processor.process_createOrder
2281 
    self._processMap["getOrder"] = Processor.process_getOrder
2282 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 2283 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
1220 chandransh 2284 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 2285 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
759 chandransh 2286 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
1113 chandransh 2287 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 2288 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 2289 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 2290 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 2291 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
304 ashish 2292 
    self._processMap["getAlerts"] = Processor.process_getAlerts
2293 
    self._processMap["setAlert"] = Processor.process_setAlert
1596 ankur.sing 2294 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
1627 ankur.sing 2295 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
1731 ankur.sing 2296 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
1886 ankur.sing 2297 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
2536 chandransh 2298 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
2299 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
2300 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 2301 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
2616 chandransh 2302 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 2303 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 2304 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
2305 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 2306 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 2307 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 2308 
    self._processMap["processReturn"] = Processor.process_processReturn
2819 chandransh 2309 
    self._processMap["createPurchaseOrder"] = Processor.process_createPurchaseOrder
94 ashish 2310 
 
2311 
  def process(self, iprot, oprot):
2312 
    (name, type, seqid) = iprot.readMessageBegin()
2313 
    if name not in self._processMap:
2314 
      iprot.skip(TType.STRUCT)
2315 
      iprot.readMessageEnd()
2316 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2317 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2318 
      x.write(oprot)
2319 
      oprot.writeMessageEnd()
2320 
      oprot.trans.flush()
2321 
      return
2322 
    else:
2323 
      self._processMap[name](self, seqid, iprot, oprot)
2324 
    return True
2325 
 
765 rajveer 2326 
  def process_closeSession(self, seqid, iprot, oprot):
2327 
    args = closeSession_args()
2328 
    args.read(iprot)
2329 
    iprot.readMessageEnd()
2330 
    result = closeSession_result()
2331 
    self._handler.closeSession()
2332 
    oprot.writeMessageBegin("closeSession", TMessageType.REPLY, seqid)
2333 
    result.write(oprot)
2334 
    oprot.writeMessageEnd()
2335 
    oprot.trans.flush()
2336 
 
94 ashish 2337 
  def process_createTransaction(self, seqid, iprot, oprot):
2338 
    args = createTransaction_args()
2339 
    args.read(iprot)
2340 
    iprot.readMessageEnd()
2341 
    result = createTransaction_result()
2342 
    try:
132 ashish 2343 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 2344 
    except TransactionServiceException, ex:
2345 
      result.ex = ex
2346 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
2347 
    result.write(oprot)
2348 
    oprot.writeMessageEnd()
2349 
    oprot.trans.flush()
2350 
 
2351 
  def process_getTransaction(self, seqid, iprot, oprot):
2352 
    args = getTransaction_args()
2353 
    args.read(iprot)
2354 
    iprot.readMessageEnd()
2355 
    result = getTransaction_result()
2356 
    try:
2357 
      result.success = self._handler.getTransaction(args.id)
2358 
    except TransactionServiceException, ex:
2359 
      result.ex = ex
2360 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
2361 
    result.write(oprot)
2362 
    oprot.writeMessageEnd()
2363 
    oprot.trans.flush()
2364 
 
2365 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
2366 
    args = getTransactionsForCustomer_args()
2367 
    args.read(iprot)
2368 
    iprot.readMessageEnd()
2369 
    result = getTransactionsForCustomer_result()
2370 
    try:
2371 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
2372 
    except TransactionServiceException, ex:
2373 
      result.ex = ex
2374 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
2375 
    result.write(oprot)
2376 
    oprot.writeMessageEnd()
2377 
    oprot.trans.flush()
2378 
 
132 ashish 2379 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
2380 
    args = getTransactionsForShoppingCartId_args()
2381 
    args.read(iprot)
2382 
    iprot.readMessageEnd()
2383 
    result = getTransactionsForShoppingCartId_result()
2384 
    try:
2385 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
2386 
    except TransactionServiceException, ex:
2387 
      result.ex = ex
2388 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
2389 
    result.write(oprot)
2390 
    oprot.writeMessageEnd()
2391 
    oprot.trans.flush()
2392 
 
94 ashish 2393 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
2394 
    args = getTransactionStatus_args()
2395 
    args.read(iprot)
2396 
    iprot.readMessageEnd()
2397 
    result = getTransactionStatus_result()
2398 
    try:
2399 
      result.success = self._handler.getTransactionStatus(args.transactionId)
2400 
    except TransactionServiceException, ex:
2401 
      result.ex = ex
2402 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
2403 
    result.write(oprot)
2404 
    oprot.writeMessageEnd()
2405 
    oprot.trans.flush()
2406 
 
2407 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
2408 
    args = changeTransactionStatus_args()
2409 
    args.read(iprot)
2410 
    iprot.readMessageEnd()
2411 
    result = changeTransactionStatus_result()
2412 
    try:
2413 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
2414 
    except TransactionServiceException, ex:
2415 
      result.ex = ex
2416 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
2417 
    result.write(oprot)
2418 
    oprot.writeMessageEnd()
2419 
    oprot.trans.flush()
2420 
 
1398 varun.gupt 2421 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
2422 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 2423 
    args.read(iprot)
2424 
    iprot.readMessageEnd()
1398 varun.gupt 2425 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 2426 
    try:
1398 varun.gupt 2427 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 2428 
    except TransactionServiceException, ex:
2429 
      result.ex = ex
1398 varun.gupt 2430 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 2431 
    result.write(oprot)
2432 
    oprot.writeMessageEnd()
2433 
    oprot.trans.flush()
2434 
 
483 rajveer 2435 
  def process_getAllOrders(self, seqid, iprot, oprot):
2436 
    args = getAllOrders_args()
94 ashish 2437 
    args.read(iprot)
2438 
    iprot.readMessageEnd()
483 rajveer 2439 
    result = getAllOrders_result()
94 ashish 2440 
    try:
483 rajveer 2441 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 2442 
    except TransactionServiceException, ex:
2443 
      result.ex = ex
483 rajveer 2444 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 2445 
    result.write(oprot)
2446 
    oprot.writeMessageEnd()
2447 
    oprot.trans.flush()
2448 
 
999 varun.gupt 2449 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
2450 
    args = getOrdersByBillingDate_args()
2451 
    args.read(iprot)
2452 
    iprot.readMessageEnd()
2453 
    result = getOrdersByBillingDate_result()
2454 
    try:
2455 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
2456 
    except TransactionServiceException, ex:
2457 
      result.ex = ex
2458 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
2459 
    result.write(oprot)
2460 
    oprot.writeMessageEnd()
2461 
    oprot.trans.flush()
2462 
 
1382 varun.gupt 2463 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
2464 
    args = getReturnableOrdersForCustomer_args()
2465 
    args.read(iprot)
2466 
    iprot.readMessageEnd()
2467 
    result = getReturnableOrdersForCustomer_result()
2468 
    try:
2469 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
2470 
    except TransactionServiceException, ex:
2471 
      result.ex = ex
2472 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
2473 
    result.write(oprot)
2474 
    oprot.writeMessageEnd()
2475 
    oprot.trans.flush()
2476 
 
2477 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
2478 
    args = getCancellableOrdersForCustomer_args()
2479 
    args.read(iprot)
2480 
    iprot.readMessageEnd()
2481 
    result = getCancellableOrdersForCustomer_result()
2482 
    try:
2483 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
2484 
    except TransactionServiceException, ex:
2485 
      result.ex = ex
2486 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
2487 
    result.write(oprot)
2488 
    oprot.writeMessageEnd()
2489 
    oprot.trans.flush()
2490 
 
483 rajveer 2491 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
2492 
    args = changeOrderStatus_args()
94 ashish 2493 
    args.read(iprot)
2494 
    iprot.readMessageEnd()
483 rajveer 2495 
    result = changeOrderStatus_result()
94 ashish 2496 
    try:
483 rajveer 2497 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 2498 
    except TransactionServiceException, ex:
2499 
      result.ex = ex
483 rajveer 2500 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 2501 
    result.write(oprot)
2502 
    oprot.writeMessageEnd()
2503 
    oprot.trans.flush()
2504 
 
494 rajveer 2505 
  def process_addBillingDetails(self, seqid, iprot, oprot):
2506 
    args = addBillingDetails_args()
2507 
    args.read(iprot)
2508 
    iprot.readMessageEnd()
2509 
    result = addBillingDetails_result()
2510 
    try:
1149 chandransh 2511 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.billed_by)
494 rajveer 2512 
    except TransactionServiceException, ex:
2513 
      result.ex = ex
2514 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
2515 
    result.write(oprot)
2516 
    oprot.writeMessageEnd()
2517 
    oprot.trans.flush()
2518 
 
1149 chandransh 2519 
  def process_addJacketNumber(self, seqid, iprot, oprot):
2520 
    args = addJacketNumber_args()
2521 
    args.read(iprot)
2522 
    iprot.readMessageEnd()
2523 
    result = addJacketNumber_result()
2524 
    try:
2842 chandransh 2525 
      result.success = self._handler.addJacketNumber(args.orderId, args.jacketNumber, args.imeiNumber, args.itemNumber, args.billedBy, args.billingType)
1149 chandransh 2526 
    except TransactionServiceException, ex:
2527 
      result.ex = ex
2528 
    oprot.writeMessageBegin("addJacketNumber", TMessageType.REPLY, seqid)
2529 
    result.write(oprot)
2530 
    oprot.writeMessageEnd()
2531 
    oprot.trans.flush()
2532 
 
921 rajveer 2533 
  def process_acceptOrder(self, seqid, iprot, oprot):
2534 
    args = acceptOrder_args()
2535 
    args.read(iprot)
2536 
    iprot.readMessageEnd()
2537 
    result = acceptOrder_result()
2538 
    try:
2539 
      result.success = self._handler.acceptOrder(args.orderId)
2540 
    except TransactionServiceException, ex:
2541 
      result.ex = ex
2542 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
2543 
    result.write(oprot)
2544 
    oprot.writeMessageEnd()
2545 
    oprot.trans.flush()
2546 
 
2547 
  def process_billOrder(self, seqid, iprot, oprot):
2548 
    args = billOrder_args()
2549 
    args.read(iprot)
2550 
    iprot.readMessageEnd()
2551 
    result = billOrder_result()
2552 
    try:
2553 
      result.success = self._handler.billOrder(args.orderId)
2554 
    except TransactionServiceException, ex:
2555 
      result.ex = ex
2556 
    oprot.writeMessageBegin("billOrder", TMessageType.REPLY, seqid)
2557 
    result.write(oprot)
2558 
    oprot.writeMessageEnd()
2559 
    oprot.trans.flush()
2560 
 
483 rajveer 2561 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
2562 
    args = getOrdersForTransaction_args()
94 ashish 2563 
    args.read(iprot)
2564 
    iprot.readMessageEnd()
483 rajveer 2565 
    result = getOrdersForTransaction_result()
94 ashish 2566 
    try:
1528 ankur.sing 2567 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 2568 
    except TransactionServiceException, ex:
2569 
      result.ex = ex
483 rajveer 2570 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 2571 
    result.write(oprot)
2572 
    oprot.writeMessageEnd()
2573 
    oprot.trans.flush()
2574 
 
483 rajveer 2575 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
2576 
    args = getOrdersForCustomer_args()
94 ashish 2577 
    args.read(iprot)
2578 
    iprot.readMessageEnd()
483 rajveer 2579 
    result = getOrdersForCustomer_result()
94 ashish 2580 
    try:
3014 chandransh 2581 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 2582 
    except TransactionServiceException, ex:
2583 
      result.ex = ex
483 rajveer 2584 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 2585 
    result.write(oprot)
2586 
    oprot.writeMessageEnd()
2587 
    oprot.trans.flush()
2588 
 
483 rajveer 2589 
  def process_createOrder(self, seqid, iprot, oprot):
2590 
    args = createOrder_args()
94 ashish 2591 
    args.read(iprot)
2592 
    iprot.readMessageEnd()
483 rajveer 2593 
    result = createOrder_result()
94 ashish 2594 
    try:
483 rajveer 2595 
      result.success = self._handler.createOrder(args.order)
94 ashish 2596 
    except TransactionServiceException, ex:
2597 
      result.ex = ex
483 rajveer 2598 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 2599 
    result.write(oprot)
2600 
    oprot.writeMessageEnd()
2601 
    oprot.trans.flush()
2602 
 
483 rajveer 2603 
  def process_getOrder(self, seqid, iprot, oprot):
2604 
    args = getOrder_args()
94 ashish 2605 
    args.read(iprot)
2606 
    iprot.readMessageEnd()
483 rajveer 2607 
    result = getOrder_result()
94 ashish 2608 
    try:
483 rajveer 2609 
      result.success = self._handler.getOrder(args.id)
94 ashish 2610 
    except TransactionServiceException, ex:
2611 
      result.ex = ex
483 rajveer 2612 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 2613 
    result.write(oprot)
2614 
    oprot.writeMessageEnd()
2615 
    oprot.trans.flush()
2616 
 
483 rajveer 2617 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
2618 
    args = getLineItemsForOrder_args()
94 ashish 2619 
    args.read(iprot)
2620 
    iprot.readMessageEnd()
483 rajveer 2621 
    result = getLineItemsForOrder_result()
94 ashish 2622 
    try:
483 rajveer 2623 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 2624 
    except TransactionServiceException, ex:
2625 
      result.ex = ex
483 rajveer 2626 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 2627 
    result.write(oprot)
2628 
    oprot.writeMessageEnd()
2629 
    oprot.trans.flush()
2630 
 
1528 ankur.sing 2631 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
2632 
    args = getOrderForCustomer_args()
2633 
    args.read(iprot)
2634 
    iprot.readMessageEnd()
2635 
    result = getOrderForCustomer_result()
2636 
    try:
2637 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
2638 
    except TransactionServiceException, ex:
2639 
      result.ex = ex
2640 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
2641 
    result.write(oprot)
2642 
    oprot.writeMessageEnd()
2643 
    oprot.trans.flush()
2644 
 
1220 chandransh 2645 
  def process_batchOrders(self, seqid, iprot, oprot):
2646 
    args = batchOrders_args()
2647 
    args.read(iprot)
2648 
    iprot.readMessageEnd()
2649 
    result = batchOrders_result()
2650 
    try:
2651 
      result.success = self._handler.batchOrders(args.warehouseId)
2652 
    except TransactionServiceException, ex:
2653 
      result.ex = ex
2654 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
2655 
    result.write(oprot)
2656 
    oprot.writeMessageEnd()
2657 
    oprot.trans.flush()
2658 
 
1208 chandransh 2659 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
2660 
    args = markOrderAsOutOfStock_args()
2661 
    args.read(iprot)
2662 
    iprot.readMessageEnd()
2663 
    result = markOrderAsOutOfStock_result()
2664 
    try:
2665 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
2666 
    except TransactionServiceException, ex:
2667 
      result.ex = ex
2668 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
2669 
    result.write(oprot)
2670 
    oprot.writeMessageEnd()
2671 
    oprot.trans.flush()
2672 
 
759 chandransh 2673 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
2674 
    args = markOrdersAsManifested_args()
2675 
    args.read(iprot)
2676 
    iprot.readMessageEnd()
2677 
    result = markOrdersAsManifested_result()
2678 
    try:
2679 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId)
2680 
    except TransactionServiceException, ex:
2681 
      result.ex = ex
2682 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
2683 
    result.write(oprot)
2684 
    oprot.writeMessageEnd()
2685 
    oprot.trans.flush()
2686 
 
1113 chandransh 2687 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
2688 
    args = markOrdersAsPickedUp_args()
2689 
    args.read(iprot)
2690 
    iprot.readMessageEnd()
2691 
    result = markOrdersAsPickedUp_result()
2692 
    try:
2693 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
2694 
    except TransactionServiceException, ex:
2695 
      result.ex = ex
2696 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
2697 
    result.write(oprot)
2698 
    oprot.writeMessageEnd()
2699 
    oprot.trans.flush()
2700 
 
1132 chandransh 2701 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
2702 
    args = markOrdersAsDelivered_args()
2703 
    args.read(iprot)
2704 
    iprot.readMessageEnd()
2705 
    result = markOrdersAsDelivered_result()
2706 
    try:
2707 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
2708 
    except TransactionServiceException, ex:
2709 
      result.ex = ex
2710 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
2711 
    result.write(oprot)
2712 
    oprot.writeMessageEnd()
2713 
    oprot.trans.flush()
2714 
 
1135 chandransh 2715 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
2716 
    args = markOrdersAsFailed_args()
2717 
    args.read(iprot)
2718 
    iprot.readMessageEnd()
2719 
    result = markOrdersAsFailed_result()
2720 
    try:
2721 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
2722 
    except TransactionServiceException, ex:
2723 
      result.ex = ex
2724 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
2725 
    result.write(oprot)
2726 
    oprot.writeMessageEnd()
2727 
    oprot.trans.flush()
2728 
 
1246 chandransh 2729 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
2730 
    args = updateNonDeliveryReason_args()
2731 
    args.read(iprot)
2732 
    iprot.readMessageEnd()
2733 
    result = updateNonDeliveryReason_result()
2734 
    try:
2735 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
2736 
    except TransactionServiceException, ex:
2737 
      result.ex = ex
2738 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
2739 
    result.write(oprot)
2740 
    oprot.writeMessageEnd()
2741 
    oprot.trans.flush()
2742 
 
1408 ankur.sing 2743 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
2744 
    args = getUndeliveredOrders_args()
2745 
    args.read(iprot)
2746 
    iprot.readMessageEnd()
2747 
    result = getUndeliveredOrders_result()
2748 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
2749 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
2750 
    result.write(oprot)
2751 
    oprot.writeMessageEnd()
2752 
    oprot.trans.flush()
2753 
 
304 ashish 2754 
  def process_getAlerts(self, seqid, iprot, oprot):
2755 
    args = getAlerts_args()
2756 
    args.read(iprot)
2757 
    iprot.readMessageEnd()
2758 
    result = getAlerts_result()
483 rajveer 2759 
    result.success = self._handler.getAlerts(args.orderId, args.valid)
304 ashish 2760 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
2761 
    result.write(oprot)
2762 
    oprot.writeMessageEnd()
2763 
    oprot.trans.flush()
94 ashish 2764 
 
304 ashish 2765 
  def process_setAlert(self, seqid, iprot, oprot):
2766 
    args = setAlert_args()
2767 
    args.read(iprot)
2768 
    iprot.readMessageEnd()
2769 
    result = setAlert_result()
483 rajveer 2770 
    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
304 ashish 2771 
    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
2772 
    result.write(oprot)
2773 
    oprot.writeMessageEnd()
2774 
    oprot.trans.flush()
2775 
 
1596 ankur.sing 2776 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
2777 
    args = getValidOrderCount_args()
2778 
    args.read(iprot)
2779 
    iprot.readMessageEnd()
2780 
    result = getValidOrderCount_result()
2781 
    result.success = self._handler.getValidOrderCount()
2782 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
2783 
    result.write(oprot)
2784 
    oprot.writeMessageEnd()
2785 
    oprot.trans.flush()
304 ashish 2786 
 
1627 ankur.sing 2787 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
2788 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2789 
    args.read(iprot)
2790 
    iprot.readMessageEnd()
2791 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2792 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
2793 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
2794 
    result.write(oprot)
2795 
    oprot.writeMessageEnd()
2796 
    oprot.trans.flush()
1596 ankur.sing 2797 
 
1731 ankur.sing 2798 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
2799 
    args = getValidOrdersAmountRange_args()
1627 ankur.sing 2800 
    args.read(iprot)
2801 
    iprot.readMessageEnd()
1731 ankur.sing 2802 
    result = getValidOrdersAmountRange_result()
2803 
    result.success = self._handler.getValidOrdersAmountRange()
2804 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
1627 ankur.sing 2805 
    result.write(oprot)
2806 
    oprot.writeMessageEnd()
2807 
    oprot.trans.flush()
2808 
 
1886 ankur.sing 2809 
  def process_getValidOrders(self, seqid, iprot, oprot):
2810 
    args = getValidOrders_args()
2811 
    args.read(iprot)
2812 
    iprot.readMessageEnd()
2813 
    result = getValidOrders_result()
2814 
    result.success = self._handler.getValidOrders(args.limit)
2815 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
2816 
    result.write(oprot)
2817 
    oprot.writeMessageEnd()
2818 
    oprot.trans.flush()
1627 ankur.sing 2819 
 
2536 chandransh 2820 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
2821 
    args = toggleDOAFlag_args()
2822 
    args.read(iprot)
2823 
    iprot.readMessageEnd()
2824 
    result = toggleDOAFlag_result()
2825 
    try:
2826 
      result.success = self._handler.toggleDOAFlag(args.orderId)
2827 
    except TransactionServiceException, ex:
2828 
      result.ex = ex
2829 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
2830 
    result.write(oprot)
2831 
    oprot.writeMessageEnd()
2832 
    oprot.trans.flush()
1886 ankur.sing 2833 
 
2536 chandransh 2834 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
2835 
    args = requestPickupNumber_args()
2836 
    args.read(iprot)
2837 
    iprot.readMessageEnd()
2838 
    result = requestPickupNumber_result()
2839 
    try:
2840 
      result.success = self._handler.requestPickupNumber(args.orderId)
2841 
    except TransactionServiceException, ex:
2842 
      result.ex = ex
2843 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
2844 
    result.write(oprot)
2845 
    oprot.writeMessageEnd()
2846 
    oprot.trans.flush()
2847 
 
2848 
  def process_authorizePickup(self, seqid, iprot, oprot):
2849 
    args = authorizePickup_args()
2850 
    args.read(iprot)
2851 
    iprot.readMessageEnd()
2852 
    result = authorizePickup_result()
2853 
    try:
2854 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
2855 
    except TransactionServiceException, ex:
2856 
      result.ex = ex
2857 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
2858 
    result.write(oprot)
2859 
    oprot.writeMessageEnd()
2860 
    oprot.trans.flush()
2861 
 
2764 chandransh 2862 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
2863 
    args = markDoasAsPickedUp_args()
2864 
    args.read(iprot)
2865 
    iprot.readMessageEnd()
2866 
    result = markDoasAsPickedUp_result()
2867 
    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2868 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
2869 
    result.write(oprot)
2870 
    oprot.writeMessageEnd()
2871 
    oprot.trans.flush()
2872 
 
2616 chandransh 2873 
  def process_receiveReturn(self, seqid, iprot, oprot):
2874 
    args = receiveReturn_args()
2591 chandransh 2875 
    args.read(iprot)
2876 
    iprot.readMessageEnd()
2616 chandransh 2877 
    result = receiveReturn_result()
2591 chandransh 2878 
    try:
2616 chandransh 2879 
      result.success = self._handler.receiveReturn(args.orderId)
2591 chandransh 2880 
    except TransactionServiceException, ex:
2881 
      result.ex = ex
2616 chandransh 2882 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 2883 
    result.write(oprot)
2884 
    oprot.writeMessageEnd()
2885 
    oprot.trans.flush()
2536 chandransh 2886 
 
2591 chandransh 2887 
  def process_validateDoa(self, seqid, iprot, oprot):
2888 
    args = validateDoa_args()
2889 
    args.read(iprot)
2890 
    iprot.readMessageEnd()
2891 
    result = validateDoa_result()
2892 
    try:
2893 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
2894 
    except TransactionServiceException, ex:
2895 
      result.ex = ex
2896 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
2897 
    result.write(oprot)
2898 
    oprot.writeMessageEnd()
2899 
    oprot.trans.flush()
2900 
 
2616 chandransh 2901 
  def process_reshipOrder(self, seqid, iprot, oprot):
2902 
    args = reshipOrder_args()
2903 
    args.read(iprot)
2904 
    iprot.readMessageEnd()
2905 
    result = reshipOrder_result()
2906 
    try:
2907 
      result.success = self._handler.reshipOrder(args.orderId)
2908 
    except TransactionServiceException, ex:
2909 
      result.ex = ex
2910 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
2911 
    result.write(oprot)
2912 
    oprot.writeMessageEnd()
2913 
    oprot.trans.flush()
2591 chandransh 2914 
 
2616 chandransh 2915 
  def process_refundOrder(self, seqid, iprot, oprot):
2916 
    args = refundOrder_args()
2917 
    args.read(iprot)
2918 
    iprot.readMessageEnd()
2919 
    result = refundOrder_result()
2920 
    try:
2921 
      result.success = self._handler.refundOrder(args.orderId)
2922 
    except TransactionServiceException, ex:
2923 
      result.ex = ex
2924 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
2925 
    result.write(oprot)
2926 
    oprot.writeMessageEnd()
2927 
    oprot.trans.flush()
2928 
 
2690 chandransh 2929 
  def process_getReturnOrders(self, seqid, iprot, oprot):
2930 
    args = getReturnOrders_args()
2931 
    args.read(iprot)
2932 
    iprot.readMessageEnd()
2933 
    result = getReturnOrders_result()
2934 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
2935 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
2936 
    result.write(oprot)
2937 
    oprot.writeMessageEnd()
2938 
    oprot.trans.flush()
2616 chandransh 2939 
 
2700 chandransh 2940 
  def process_getReturnOrder(self, seqid, iprot, oprot):
2941 
    args = getReturnOrder_args()
2942 
    args.read(iprot)
2943 
    iprot.readMessageEnd()
2944 
    result = getReturnOrder_result()
2945 
    try:
2946 
      result.success = self._handler.getReturnOrder(args.id)
2947 
    except TransactionServiceException, ex:
2948 
      result.ex = ex
2949 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
2950 
    result.write(oprot)
2951 
    oprot.writeMessageEnd()
2952 
    oprot.trans.flush()
2953 
 
2690 chandransh 2954 
  def process_processReturn(self, seqid, iprot, oprot):
2955 
    args = processReturn_args()
2956 
    args.read(iprot)
2957 
    iprot.readMessageEnd()
2958 
    result = processReturn_result()
2959 
    try:
2960 
      self._handler.processReturn(args.returnOrderId)
2961 
    except TransactionServiceException, ex:
2962 
      result.ex = ex
2963 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
2964 
    result.write(oprot)
2965 
    oprot.writeMessageEnd()
2966 
    oprot.trans.flush()
2967 
 
2819 chandransh 2968 
  def process_createPurchaseOrder(self, seqid, iprot, oprot):
2969 
    args = createPurchaseOrder_args()
2970 
    args.read(iprot)
2971 
    iprot.readMessageEnd()
2972 
    result = createPurchaseOrder_result()
2973 
    try:
2974 
      result.success = self._handler.createPurchaseOrder(args.warehouseId)
2975 
    except TransactionServiceException, ex:
2976 
      result.ex = ex
2977 
    oprot.writeMessageBegin("createPurchaseOrder", TMessageType.REPLY, seqid)
2978 
    result.write(oprot)
2979 
    oprot.writeMessageEnd()
2980 
    oprot.trans.flush()
2690 chandransh 2981 
 
2819 chandransh 2982 
 
94 ashish 2983 
# HELPER FUNCTIONS AND STRUCTURES
2984 
 
765 rajveer 2985 
class closeSession_args:
2986 
 
2987 
  thrift_spec = (
2988 
  )
2989 
 
2990 
  def read(self, iprot):
2991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2993 
      return
2994 
    iprot.readStructBegin()
2995 
    while True:
2996 
      (fname, ftype, fid) = iprot.readFieldBegin()
2997 
      if ftype == TType.STOP:
2998 
        break
2999 
      else:
3000 
        iprot.skip(ftype)
3001 
      iprot.readFieldEnd()
3002 
    iprot.readStructEnd()
3003 
 
3004 
  def write(self, oprot):
3005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3007 
      return
3008 
    oprot.writeStructBegin('closeSession_args')
3009 
    oprot.writeFieldStop()
3010 
    oprot.writeStructEnd()
3011 
 
3012 
  def __repr__(self):
3013 
    L = ['%s=%r' % (key, value)
3014 
      for key, value in self.__dict__.iteritems()]
3015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3016 
 
3017 
  def __eq__(self, other):
3018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3019 
 
3020 
  def __ne__(self, other):
3021 
    return not (self == other)
3022 
 
3023 
class closeSession_result:
3024 
 
3025 
  thrift_spec = (
3026 
  )
3027 
 
3028 
  def read(self, iprot):
3029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3031 
      return
3032 
    iprot.readStructBegin()
3033 
    while True:
3034 
      (fname, ftype, fid) = iprot.readFieldBegin()
3035 
      if ftype == TType.STOP:
3036 
        break
3037 
      else:
3038 
        iprot.skip(ftype)
3039 
      iprot.readFieldEnd()
3040 
    iprot.readStructEnd()
3041 
 
3042 
  def write(self, oprot):
3043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3045 
      return
3046 
    oprot.writeStructBegin('closeSession_result')
3047 
    oprot.writeFieldStop()
3048 
    oprot.writeStructEnd()
3049 
 
3050 
  def __repr__(self):
3051 
    L = ['%s=%r' % (key, value)
3052 
      for key, value in self.__dict__.iteritems()]
3053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3054 
 
3055 
  def __eq__(self, other):
3056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3057 
 
3058 
  def __ne__(self, other):
3059 
    return not (self == other)
3060 
 
94 ashish 3061 
class createTransaction_args:
3062 
  """
3063 
  Attributes:
3064 
   - transaction
3065 
  """
3066 
 
3067 
  thrift_spec = (
3068 
    None, # 0
3069 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
3070 
  )
3071 
 
3072 
  def __init__(self, transaction=None,):
3073 
    self.transaction = transaction
3074 
 
3075 
  def read(self, iprot):
3076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3078 
      return
3079 
    iprot.readStructBegin()
3080 
    while True:
3081 
      (fname, ftype, fid) = iprot.readFieldBegin()
3082 
      if ftype == TType.STOP:
3083 
        break
3084 
      if fid == 1:
3085 
        if ftype == TType.STRUCT:
3086 
          self.transaction = Transaction()
3087 
          self.transaction.read(iprot)
3088 
        else:
3089 
          iprot.skip(ftype)
3090 
      else:
3091 
        iprot.skip(ftype)
3092 
      iprot.readFieldEnd()
3093 
    iprot.readStructEnd()
3094 
 
3095 
  def write(self, oprot):
3096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3098 
      return
3099 
    oprot.writeStructBegin('createTransaction_args')
3100 
    if self.transaction != None:
3101 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
3102 
      self.transaction.write(oprot)
3103 
      oprot.writeFieldEnd()
3104 
    oprot.writeFieldStop()
3105 
    oprot.writeStructEnd()
3106 
 
3107 
  def __repr__(self):
3108 
    L = ['%s=%r' % (key, value)
3109 
      for key, value in self.__dict__.iteritems()]
3110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3111 
 
3112 
  def __eq__(self, other):
3113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3114 
 
3115 
  def __ne__(self, other):
3116 
    return not (self == other)
3117 
 
3118 
class createTransaction_result:
3119 
  """
3120 
  Attributes:
132 ashish 3121 
   - success
94 ashish 3122 
   - ex
3123 
  """
3124 
 
3125 
  thrift_spec = (
132 ashish 3126 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 3127 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3128 
  )
3129 
 
132 ashish 3130 
  def __init__(self, success=None, ex=None,):
3131 
    self.success = success
94 ashish 3132 
    self.ex = ex
3133 
 
3134 
  def read(self, iprot):
3135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3137 
      return
3138 
    iprot.readStructBegin()
3139 
    while True:
3140 
      (fname, ftype, fid) = iprot.readFieldBegin()
3141 
      if ftype == TType.STOP:
3142 
        break
132 ashish 3143 
      if fid == 0:
3144 
        if ftype == TType.I64:
3145 
          self.success = iprot.readI64();
3146 
        else:
3147 
          iprot.skip(ftype)
3148 
      elif fid == 1:
94 ashish 3149 
        if ftype == TType.STRUCT:
3150 
          self.ex = TransactionServiceException()
3151 
          self.ex.read(iprot)
3152 
        else:
3153 
          iprot.skip(ftype)
3154 
      else:
3155 
        iprot.skip(ftype)
3156 
      iprot.readFieldEnd()
3157 
    iprot.readStructEnd()
3158 
 
3159 
  def write(self, oprot):
3160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3162 
      return
3163 
    oprot.writeStructBegin('createTransaction_result')
132 ashish 3164 
    if self.success != None:
3165 
      oprot.writeFieldBegin('success', TType.I64, 0)
3166 
      oprot.writeI64(self.success)
3167 
      oprot.writeFieldEnd()
94 ashish 3168 
    if self.ex != None:
3169 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3170 
      self.ex.write(oprot)
3171 
      oprot.writeFieldEnd()
3172 
    oprot.writeFieldStop()
3173 
    oprot.writeStructEnd()
3174 
 
3175 
  def __repr__(self):
3176 
    L = ['%s=%r' % (key, value)
3177 
      for key, value in self.__dict__.iteritems()]
3178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3179 
 
3180 
  def __eq__(self, other):
3181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3182 
 
3183 
  def __ne__(self, other):
3184 
    return not (self == other)
3185 
 
3186 
class getTransaction_args:
3187 
  """
3188 
  Attributes:
3189 
   - id
3190 
  """
3191 
 
3192 
  thrift_spec = (
3193 
    None, # 0
3194 
    (1, TType.I64, 'id', None, None, ), # 1
3195 
  )
3196 
 
3197 
  def __init__(self, id=None,):
3198 
    self.id = id
3199 
 
3200 
  def read(self, iprot):
3201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3203 
      return
3204 
    iprot.readStructBegin()
3205 
    while True:
3206 
      (fname, ftype, fid) = iprot.readFieldBegin()
3207 
      if ftype == TType.STOP:
3208 
        break
3209 
      if fid == 1:
3210 
        if ftype == TType.I64:
3211 
          self.id = iprot.readI64();
3212 
        else:
3213 
          iprot.skip(ftype)
3214 
      else:
3215 
        iprot.skip(ftype)
3216 
      iprot.readFieldEnd()
3217 
    iprot.readStructEnd()
3218 
 
3219 
  def write(self, oprot):
3220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3222 
      return
3223 
    oprot.writeStructBegin('getTransaction_args')
3224 
    if self.id != None:
3225 
      oprot.writeFieldBegin('id', TType.I64, 1)
3226 
      oprot.writeI64(self.id)
3227 
      oprot.writeFieldEnd()
3228 
    oprot.writeFieldStop()
3229 
    oprot.writeStructEnd()
3230 
 
3231 
  def __repr__(self):
3232 
    L = ['%s=%r' % (key, value)
3233 
      for key, value in self.__dict__.iteritems()]
3234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3235 
 
3236 
  def __eq__(self, other):
3237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3238 
 
3239 
  def __ne__(self, other):
3240 
    return not (self == other)
3241 
 
3242 
class getTransaction_result:
3243 
  """
3244 
  Attributes:
3245 
   - success
3246 
   - ex
3247 
  """
3248 
 
3249 
  thrift_spec = (
3250 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
3251 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3252 
  )
3253 
 
3254 
  def __init__(self, success=None, ex=None,):
3255 
    self.success = success
3256 
    self.ex = ex
3257 
 
3258 
  def read(self, iprot):
3259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3261 
      return
3262 
    iprot.readStructBegin()
3263 
    while True:
3264 
      (fname, ftype, fid) = iprot.readFieldBegin()
3265 
      if ftype == TType.STOP:
3266 
        break
3267 
      if fid == 0:
3268 
        if ftype == TType.STRUCT:
3269 
          self.success = Transaction()
3270 
          self.success.read(iprot)
3271 
        else:
3272 
          iprot.skip(ftype)
3273 
      elif fid == 1:
3274 
        if ftype == TType.STRUCT:
3275 
          self.ex = TransactionServiceException()
3276 
          self.ex.read(iprot)
3277 
        else:
3278 
          iprot.skip(ftype)
3279 
      else:
3280 
        iprot.skip(ftype)
3281 
      iprot.readFieldEnd()
3282 
    iprot.readStructEnd()
3283 
 
3284 
  def write(self, oprot):
3285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3287 
      return
3288 
    oprot.writeStructBegin('getTransaction_result')
3289 
    if self.success != None:
3290 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3291 
      self.success.write(oprot)
3292 
      oprot.writeFieldEnd()
3293 
    if self.ex != None:
3294 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3295 
      self.ex.write(oprot)
3296 
      oprot.writeFieldEnd()
3297 
    oprot.writeFieldStop()
3298 
    oprot.writeStructEnd()
3299 
 
3300 
  def __repr__(self):
3301 
    L = ['%s=%r' % (key, value)
3302 
      for key, value in self.__dict__.iteritems()]
3303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3304 
 
3305 
  def __eq__(self, other):
3306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3307 
 
3308 
  def __ne__(self, other):
3309 
    return not (self == other)
3310 
 
3311 
class getTransactionsForCustomer_args:
3312 
  """
3313 
  Attributes:
3314 
   - customerId
3315 
   - from_date
3316 
   - to_date
3317 
   - status
3318 
  """
3319 
 
3320 
  thrift_spec = (
3321 
    None, # 0
3322 
    (1, TType.I64, 'customerId', None, None, ), # 1
3323 
    (2, TType.I64, 'from_date', None, None, ), # 2
3324 
    (3, TType.I64, 'to_date', None, None, ), # 3
3325 
    (4, TType.I32, 'status', None, None, ), # 4
3326 
  )
3327 
 
3328 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
3329 
    self.customerId = customerId
3330 
    self.from_date = from_date
3331 
    self.to_date = to_date
3332 
    self.status = status
3333 
 
3334 
  def read(self, iprot):
3335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3337 
      return
3338 
    iprot.readStructBegin()
3339 
    while True:
3340 
      (fname, ftype, fid) = iprot.readFieldBegin()
3341 
      if ftype == TType.STOP:
3342 
        break
3343 
      if fid == 1:
3344 
        if ftype == TType.I64:
3345 
          self.customerId = iprot.readI64();
3346 
        else:
3347 
          iprot.skip(ftype)
3348 
      elif fid == 2:
3349 
        if ftype == TType.I64:
3350 
          self.from_date = iprot.readI64();
3351 
        else:
3352 
          iprot.skip(ftype)
3353 
      elif fid == 3:
3354 
        if ftype == TType.I64:
3355 
          self.to_date = iprot.readI64();
3356 
        else:
3357 
          iprot.skip(ftype)
3358 
      elif fid == 4:
3359 
        if ftype == TType.I32:
3360 
          self.status = iprot.readI32();
3361 
        else:
3362 
          iprot.skip(ftype)
3363 
      else:
3364 
        iprot.skip(ftype)
3365 
      iprot.readFieldEnd()
3366 
    iprot.readStructEnd()
3367 
 
3368 
  def write(self, oprot):
3369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3371 
      return
3372 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3373 
    if self.customerId != None:
3374 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
3375 
      oprot.writeI64(self.customerId)
3376 
      oprot.writeFieldEnd()
3377 
    if self.from_date != None:
3378 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
3379 
      oprot.writeI64(self.from_date)
3380 
      oprot.writeFieldEnd()
3381 
    if self.to_date != None:
3382 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
3383 
      oprot.writeI64(self.to_date)
3384 
      oprot.writeFieldEnd()
3385 
    if self.status != None:
3386 
      oprot.writeFieldBegin('status', TType.I32, 4)
3387 
      oprot.writeI32(self.status)
3388 
      oprot.writeFieldEnd()
3389 
    oprot.writeFieldStop()
3390 
    oprot.writeStructEnd()
3391 
 
3392 
  def __repr__(self):
3393 
    L = ['%s=%r' % (key, value)
3394 
      for key, value in self.__dict__.iteritems()]
3395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3396 
 
3397 
  def __eq__(self, other):
3398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3399 
 
3400 
  def __ne__(self, other):
3401 
    return not (self == other)
3402 
 
3403 
class getTransactionsForCustomer_result:
3404 
  """
3405 
  Attributes:
3406 
   - success
3407 
   - ex
3408 
  """
3409 
 
3410 
  thrift_spec = (
3411 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
3412 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3413 
  )
3414 
 
3415 
  def __init__(self, success=None, ex=None,):
3416 
    self.success = success
3417 
    self.ex = ex
3418 
 
3419 
  def read(self, iprot):
3420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3422 
      return
3423 
    iprot.readStructBegin()
3424 
    while True:
3425 
      (fname, ftype, fid) = iprot.readFieldBegin()
3426 
      if ftype == TType.STOP:
3427 
        break
3428 
      if fid == 0:
3429 
        if ftype == TType.LIST:
3430 
          self.success = []
685 chandransh 3431 
          (_etype17, _size14) = iprot.readListBegin()
3432 
          for _i18 in xrange(_size14):
3433 
            _elem19 = Transaction()
3434 
            _elem19.read(iprot)
3435 
            self.success.append(_elem19)
94 ashish 3436 
          iprot.readListEnd()
3437 
        else:
3438 
          iprot.skip(ftype)
3439 
      elif fid == 1:
3440 
        if ftype == TType.STRUCT:
3441 
          self.ex = TransactionServiceException()
3442 
          self.ex.read(iprot)
3443 
        else:
3444 
          iprot.skip(ftype)
3445 
      else:
3446 
        iprot.skip(ftype)
3447 
      iprot.readFieldEnd()
3448 
    iprot.readStructEnd()
3449 
 
3450 
  def write(self, oprot):
3451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3453 
      return
3454 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3455 
    if self.success != None:
3456 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3457 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 3458 
      for iter20 in self.success:
3459 
        iter20.write(oprot)
94 ashish 3460 
      oprot.writeListEnd()
3461 
      oprot.writeFieldEnd()
3462 
    if self.ex != None:
3463 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3464 
      self.ex.write(oprot)
3465 
      oprot.writeFieldEnd()
3466 
    oprot.writeFieldStop()
3467 
    oprot.writeStructEnd()
3468 
 
3469 
  def __repr__(self):
3470 
    L = ['%s=%r' % (key, value)
3471 
      for key, value in self.__dict__.iteritems()]
3472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3473 
 
3474 
  def __eq__(self, other):
3475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3476 
 
3477 
  def __ne__(self, other):
3478 
    return not (self == other)
3479 
 
132 ashish 3480 
class getTransactionsForShoppingCartId_args:
3481 
  """
3482 
  Attributes:
3483 
   - shoppingCartId
3484 
  """
3485 
 
3486 
  thrift_spec = (
3487 
    None, # 0
3488 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
3489 
  )
3490 
 
3491 
  def __init__(self, shoppingCartId=None,):
3492 
    self.shoppingCartId = shoppingCartId
3493 
 
3494 
  def read(self, iprot):
3495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3497 
      return
3498 
    iprot.readStructBegin()
3499 
    while True:
3500 
      (fname, ftype, fid) = iprot.readFieldBegin()
3501 
      if ftype == TType.STOP:
3502 
        break
3503 
      if fid == 1:
3504 
        if ftype == TType.I64:
3505 
          self.shoppingCartId = iprot.readI64();
3506 
        else:
3507 
          iprot.skip(ftype)
3508 
      else:
3509 
        iprot.skip(ftype)
3510 
      iprot.readFieldEnd()
3511 
    iprot.readStructEnd()
3512 
 
3513 
  def write(self, oprot):
3514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3516 
      return
3517 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3518 
    if self.shoppingCartId != None:
3519 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
3520 
      oprot.writeI64(self.shoppingCartId)
3521 
      oprot.writeFieldEnd()
3522 
    oprot.writeFieldStop()
3523 
    oprot.writeStructEnd()
3524 
 
3525 
  def __repr__(self):
3526 
    L = ['%s=%r' % (key, value)
3527 
      for key, value in self.__dict__.iteritems()]
3528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3529 
 
3530 
  def __eq__(self, other):
3531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3532 
 
3533 
  def __ne__(self, other):
3534 
    return not (self == other)
3535 
 
3536 
class getTransactionsForShoppingCartId_result:
3537 
  """
3538 
  Attributes:
3539 
   - success
3540 
   - ex
3541 
  """
3542 
 
3543 
  thrift_spec = (
3544 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
3545 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3546 
  )
3547 
 
3548 
  def __init__(self, success=None, ex=None,):
3549 
    self.success = success
3550 
    self.ex = ex
3551 
 
3552 
  def read(self, iprot):
3553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3555 
      return
3556 
    iprot.readStructBegin()
3557 
    while True:
3558 
      (fname, ftype, fid) = iprot.readFieldBegin()
3559 
      if ftype == TType.STOP:
3560 
        break
3561 
      if fid == 0:
3562 
        if ftype == TType.LIST:
3563 
          self.success = []
685 chandransh 3564 
          (_etype24, _size21) = iprot.readListBegin()
3565 
          for _i25 in xrange(_size21):
3566 
            _elem26 = Transaction()
3567 
            _elem26.read(iprot)
3568 
            self.success.append(_elem26)
132 ashish 3569 
          iprot.readListEnd()
3570 
        else:
3571 
          iprot.skip(ftype)
3572 
      elif fid == 1:
3573 
        if ftype == TType.STRUCT:
3574 
          self.ex = TransactionServiceException()
3575 
          self.ex.read(iprot)
3576 
        else:
3577 
          iprot.skip(ftype)
3578 
      else:
3579 
        iprot.skip(ftype)
3580 
      iprot.readFieldEnd()
3581 
    iprot.readStructEnd()
3582 
 
3583 
  def write(self, oprot):
3584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3586 
      return
3587 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3588 
    if self.success != None:
3589 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3590 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 3591 
      for iter27 in self.success:
3592 
        iter27.write(oprot)
132 ashish 3593 
      oprot.writeListEnd()
3594 
      oprot.writeFieldEnd()
3595 
    if self.ex != None:
3596 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3597 
      self.ex.write(oprot)
3598 
      oprot.writeFieldEnd()
3599 
    oprot.writeFieldStop()
3600 
    oprot.writeStructEnd()
3601 
 
3602 
  def __repr__(self):
3603 
    L = ['%s=%r' % (key, value)
3604 
      for key, value in self.__dict__.iteritems()]
3605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3606 
 
3607 
  def __eq__(self, other):
3608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3609 
 
3610 
  def __ne__(self, other):
3611 
    return not (self == other)
3612 
 
94 ashish 3613 
class getTransactionStatus_args:
3614 
  """
3615 
  Attributes:
3616 
   - transactionId
3617 
  """
3618 
 
3619 
  thrift_spec = (
3620 
    None, # 0
3621 
    (1, TType.I64, 'transactionId', None, None, ), # 1
3622 
  )
3623 
 
3624 
  def __init__(self, transactionId=None,):
3625 
    self.transactionId = transactionId
3626 
 
3627 
  def read(self, iprot):
3628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3630 
      return
3631 
    iprot.readStructBegin()
3632 
    while True:
3633 
      (fname, ftype, fid) = iprot.readFieldBegin()
3634 
      if ftype == TType.STOP:
3635 
        break
3636 
      if fid == 1:
3637 
        if ftype == TType.I64:
3638 
          self.transactionId = iprot.readI64();
3639 
        else:
3640 
          iprot.skip(ftype)
3641 
      else:
3642 
        iprot.skip(ftype)
3643 
      iprot.readFieldEnd()
3644 
    iprot.readStructEnd()
3645 
 
3646 
  def write(self, oprot):
3647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3649 
      return
3650 
    oprot.writeStructBegin('getTransactionStatus_args')
3651 
    if self.transactionId != None:
3652 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
3653 
      oprot.writeI64(self.transactionId)
3654 
      oprot.writeFieldEnd()
3655 
    oprot.writeFieldStop()
3656 
    oprot.writeStructEnd()
3657 
 
3658 
  def __repr__(self):
3659 
    L = ['%s=%r' % (key, value)
3660 
      for key, value in self.__dict__.iteritems()]
3661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3662 
 
3663 
  def __eq__(self, other):
3664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3665 
 
3666 
  def __ne__(self, other):
3667 
    return not (self == other)
3668 
 
3669 
class getTransactionStatus_result:
3670 
  """
3671 
  Attributes:
3672 
   - success
3673 
   - ex
3674 
  """
3675 
 
3676 
  thrift_spec = (
3677 
    (0, TType.I32, 'success', None, None, ), # 0
3678 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3679 
  )
3680 
 
3681 
  def __init__(self, success=None, ex=None,):
3682 
    self.success = success
3683 
    self.ex = ex
3684 
 
3685 
  def read(self, iprot):
3686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3688 
      return
3689 
    iprot.readStructBegin()
3690 
    while True:
3691 
      (fname, ftype, fid) = iprot.readFieldBegin()
3692 
      if ftype == TType.STOP:
3693 
        break
3694 
      if fid == 0:
3695 
        if ftype == TType.I32:
3696 
          self.success = iprot.readI32();
3697 
        else:
3698 
          iprot.skip(ftype)
3699 
      elif fid == 1:
3700 
        if ftype == TType.STRUCT:
3701 
          self.ex = TransactionServiceException()
3702 
          self.ex.read(iprot)
3703 
        else:
3704 
          iprot.skip(ftype)
3705 
      else:
3706 
        iprot.skip(ftype)
3707 
      iprot.readFieldEnd()
3708 
    iprot.readStructEnd()
3709 
 
3710 
  def write(self, oprot):
3711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3713 
      return
3714 
    oprot.writeStructBegin('getTransactionStatus_result')
3715 
    if self.success != None:
3716 
      oprot.writeFieldBegin('success', TType.I32, 0)
3717 
      oprot.writeI32(self.success)
3718 
      oprot.writeFieldEnd()
3719 
    if self.ex != None:
3720 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3721 
      self.ex.write(oprot)
3722 
      oprot.writeFieldEnd()
3723 
    oprot.writeFieldStop()
3724 
    oprot.writeStructEnd()
3725 
 
3726 
  def __repr__(self):
3727 
    L = ['%s=%r' % (key, value)
3728 
      for key, value in self.__dict__.iteritems()]
3729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3730 
 
3731 
  def __eq__(self, other):
3732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3733 
 
3734 
  def __ne__(self, other):
3735 
    return not (self == other)
3736 
 
3737 
class changeTransactionStatus_args:
3738 
  """
3739 
  Attributes:
3740 
   - transactionId
3741 
   - status
3742 
   - description
3743 
  """
3744 
 
3745 
  thrift_spec = (
3746 
    None, # 0
3747 
    (1, TType.I64, 'transactionId', None, None, ), # 1
3748 
    (2, TType.I32, 'status', None, None, ), # 2
3749 
    (3, TType.STRING, 'description', None, None, ), # 3
3750 
  )
3751 
 
3752 
  def __init__(self, transactionId=None, status=None, description=None,):
3753 
    self.transactionId = transactionId
3754 
    self.status = status
3755 
    self.description = description
3756 
 
3757 
  def read(self, iprot):
3758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3760 
      return
3761 
    iprot.readStructBegin()
3762 
    while True:
3763 
      (fname, ftype, fid) = iprot.readFieldBegin()
3764 
      if ftype == TType.STOP:
3765 
        break
3766 
      if fid == 1:
3767 
        if ftype == TType.I64:
3768 
          self.transactionId = iprot.readI64();
3769 
        else:
3770 
          iprot.skip(ftype)
3771 
      elif fid == 2:
3772 
        if ftype == TType.I32:
3773 
          self.status = iprot.readI32();
3774 
        else:
3775 
          iprot.skip(ftype)
3776 
      elif fid == 3:
3777 
        if ftype == TType.STRING:
3778 
          self.description = iprot.readString();
3779 
        else:
3780 
          iprot.skip(ftype)
3781 
      else:
3782 
        iprot.skip(ftype)
3783 
      iprot.readFieldEnd()
3784 
    iprot.readStructEnd()
3785 
 
3786 
  def write(self, oprot):
3787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3789 
      return
3790 
    oprot.writeStructBegin('changeTransactionStatus_args')
3791 
    if self.transactionId != None:
3792 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
3793 
      oprot.writeI64(self.transactionId)
3794 
      oprot.writeFieldEnd()
3795 
    if self.status != None:
3796 
      oprot.writeFieldBegin('status', TType.I32, 2)
3797 
      oprot.writeI32(self.status)
3798 
      oprot.writeFieldEnd()
3799 
    if self.description != None:
3800 
      oprot.writeFieldBegin('description', TType.STRING, 3)
3801 
      oprot.writeString(self.description)
3802 
      oprot.writeFieldEnd()
3803 
    oprot.writeFieldStop()
3804 
    oprot.writeStructEnd()
3805 
 
3806 
  def __repr__(self):
3807 
    L = ['%s=%r' % (key, value)
3808 
      for key, value in self.__dict__.iteritems()]
3809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3810 
 
3811 
  def __eq__(self, other):
3812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3813 
 
3814 
  def __ne__(self, other):
3815 
    return not (self == other)
3816 
 
3817 
class changeTransactionStatus_result:
3818 
  """
3819 
  Attributes:
3820 
   - success
3821 
   - ex
3822 
  """
3823 
 
3824 
  thrift_spec = (
3825 
    (0, TType.BOOL, 'success', None, None, ), # 0
3826 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3827 
  )
3828 
 
3829 
  def __init__(self, success=None, ex=None,):
3830 
    self.success = success
3831 
    self.ex = ex
3832 
 
3833 
  def read(self, iprot):
3834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3836 
      return
3837 
    iprot.readStructBegin()
3838 
    while True:
3839 
      (fname, ftype, fid) = iprot.readFieldBegin()
3840 
      if ftype == TType.STOP:
3841 
        break
3842 
      if fid == 0:
3843 
        if ftype == TType.BOOL:
3844 
          self.success = iprot.readBool();
3845 
        else:
3846 
          iprot.skip(ftype)
3847 
      elif fid == 1:
3848 
        if ftype == TType.STRUCT:
3849 
          self.ex = TransactionServiceException()
3850 
          self.ex.read(iprot)
3851 
        else:
3852 
          iprot.skip(ftype)
3853 
      else:
3854 
        iprot.skip(ftype)
3855 
      iprot.readFieldEnd()
3856 
    iprot.readStructEnd()
3857 
 
3858 
  def write(self, oprot):
3859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3861 
      return
3862 
    oprot.writeStructBegin('changeTransactionStatus_result')
3863 
    if self.success != None:
3864 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3865 
      oprot.writeBool(self.success)
3866 
      oprot.writeFieldEnd()
3867 
    if self.ex != None:
3868 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3869 
      self.ex.write(oprot)
3870 
      oprot.writeFieldEnd()
3871 
    oprot.writeFieldStop()
3872 
    oprot.writeStructEnd()
3873 
 
3874 
  def __repr__(self):
3875 
    L = ['%s=%r' % (key, value)
3876 
      for key, value in self.__dict__.iteritems()]
3877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3878 
 
3879 
  def __eq__(self, other):
3880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3881 
 
3882 
  def __ne__(self, other):
3883 
    return not (self == other)
3884 
 
1398 varun.gupt 3885 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 3886 
  """
3887 
  Attributes:
3888 
   - transactionId
3889 
  """
3890 
 
3891 
  thrift_spec = (
3892 
    None, # 0
3893 
    (1, TType.I64, 'transactionId', None, None, ), # 1
3894 
  )
3895 
 
3896 
  def __init__(self, transactionId=None,):
3897 
    self.transactionId = transactionId
3898 
 
3899 
  def read(self, iprot):
3900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3902 
      return
3903 
    iprot.readStructBegin()
3904 
    while True:
3905 
      (fname, ftype, fid) = iprot.readFieldBegin()
3906 
      if ftype == TType.STOP:
3907 
        break
3908 
      if fid == 1:
3909 
        if ftype == TType.I64:
3910 
          self.transactionId = iprot.readI64();
3911 
        else:
3912 
          iprot.skip(ftype)
3913 
      else:
3914 
        iprot.skip(ftype)
3915 
      iprot.readFieldEnd()
3916 
    iprot.readStructEnd()
3917 
 
3918 
  def write(self, oprot):
3919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3921 
      return
1398 varun.gupt 3922 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
1382 varun.gupt 3923 
    if self.transactionId != None:
3924 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
3925 
      oprot.writeI64(self.transactionId)
3926 
      oprot.writeFieldEnd()
3927 
    oprot.writeFieldStop()
3928 
    oprot.writeStructEnd()
3929 
 
3930 
  def __repr__(self):
3931 
    L = ['%s=%r' % (key, value)
3932 
      for key, value in self.__dict__.iteritems()]
3933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3934 
 
3935 
  def __eq__(self, other):
3936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3937 
 
3938 
  def __ne__(self, other):
3939 
    return not (self == other)
3940 
 
1398 varun.gupt 3941 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 3942 
  """
3943 
  Attributes:
3944 
   - success
3945 
   - ex
3946 
  """
3947 
 
3948 
  thrift_spec = (
3949 
    (0, TType.BOOL, 'success', None, None, ), # 0
3950 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3951 
  )
3952 
 
3953 
  def __init__(self, success=None, ex=None,):
3954 
    self.success = success
3955 
    self.ex = ex
3956 
 
3957 
  def read(self, iprot):
3958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3960 
      return
3961 
    iprot.readStructBegin()
3962 
    while True:
3963 
      (fname, ftype, fid) = iprot.readFieldBegin()
3964 
      if ftype == TType.STOP:
3965 
        break
3966 
      if fid == 0:
3967 
        if ftype == TType.BOOL:
3968 
          self.success = iprot.readBool();
3969 
        else:
3970 
          iprot.skip(ftype)
3971 
      elif fid == 1:
3972 
        if ftype == TType.STRUCT:
3973 
          self.ex = TransactionServiceException()
3974 
          self.ex.read(iprot)
3975 
        else:
3976 
          iprot.skip(ftype)
3977 
      else:
3978 
        iprot.skip(ftype)
3979 
      iprot.readFieldEnd()
3980 
    iprot.readStructEnd()
3981 
 
3982 
  def write(self, oprot):
3983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3985 
      return
1398 varun.gupt 3986 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
1382 varun.gupt 3987 
    if self.success != None:
3988 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3989 
      oprot.writeBool(self.success)
3990 
      oprot.writeFieldEnd()
3991 
    if self.ex != None:
3992 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3993 
      self.ex.write(oprot)
3994 
      oprot.writeFieldEnd()
3995 
    oprot.writeFieldStop()
3996 
    oprot.writeStructEnd()
3997 
 
3998 
  def __repr__(self):
3999 
    L = ['%s=%r' % (key, value)
4000 
      for key, value in self.__dict__.iteritems()]
4001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4002 
 
4003 
  def __eq__(self, other):
4004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4005 
 
4006 
  def __ne__(self, other):
4007 
    return not (self == other)
4008 
 
483 rajveer 4009 
class getAllOrders_args:
94 ashish 4010 
  """
4011 
  Attributes:
483 rajveer 4012 
   - status
4013 
   - from_date
4014 
   - to_date
4015 
   - warehouse_id
94 ashish 4016 
  """
4017 
 
4018 
  thrift_spec = (
4019 
    None, # 0
483 rajveer 4020 
    (1, TType.I32, 'status', None, None, ), # 1
4021 
    (2, TType.I64, 'from_date', None, None, ), # 2
4022 
    (3, TType.I64, 'to_date', None, None, ), # 3
4023 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 4024 
  )
4025 
 
483 rajveer 4026 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
4027 
    self.status = status
4028 
    self.from_date = from_date
4029 
    self.to_date = to_date
4030 
    self.warehouse_id = warehouse_id
94 ashish 4031 
 
4032 
  def read(self, iprot):
4033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4035 
      return
4036 
    iprot.readStructBegin()
4037 
    while True:
4038 
      (fname, ftype, fid) = iprot.readFieldBegin()
4039 
      if ftype == TType.STOP:
4040 
        break
4041 
      if fid == 1:
483 rajveer 4042 
        if ftype == TType.I32:
4043 
          self.status = iprot.readI32();
94 ashish 4044 
        else:
4045 
          iprot.skip(ftype)
483 rajveer 4046 
      elif fid == 2:
4047 
        if ftype == TType.I64:
4048 
          self.from_date = iprot.readI64();
94 ashish 4049 
        else:
4050 
          iprot.skip(ftype)
483 rajveer 4051 
      elif fid == 3:
4052 
        if ftype == TType.I64:
4053 
          self.to_date = iprot.readI64();
94 ashish 4054 
        else:
4055 
          iprot.skip(ftype)
483 rajveer 4056 
      elif fid == 4:
94 ashish 4057 
        if ftype == TType.I64:
483 rajveer 4058 
          self.warehouse_id = iprot.readI64();
94 ashish 4059 
        else:
4060 
          iprot.skip(ftype)
4061 
      else:
4062 
        iprot.skip(ftype)
4063 
      iprot.readFieldEnd()
4064 
    iprot.readStructEnd()
4065 
 
4066 
  def write(self, oprot):
4067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4069 
      return
483 rajveer 4070 
    oprot.writeStructBegin('getAllOrders_args')
4071 
    if self.status != None:
4072 
      oprot.writeFieldBegin('status', TType.I32, 1)
4073 
      oprot.writeI32(self.status)
94 ashish 4074 
      oprot.writeFieldEnd()
483 rajveer 4075 
    if self.from_date != None:
4076 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4077 
      oprot.writeI64(self.from_date)
94 ashish 4078 
      oprot.writeFieldEnd()
483 rajveer 4079 
    if self.to_date != None:
4080 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4081 
      oprot.writeI64(self.to_date)
94 ashish 4082 
      oprot.writeFieldEnd()
483 rajveer 4083 
    if self.warehouse_id != None:
4084 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
4085 
      oprot.writeI64(self.warehouse_id)
94 ashish 4086 
      oprot.writeFieldEnd()
4087 
    oprot.writeFieldStop()
4088 
    oprot.writeStructEnd()
4089 
 
4090 
  def __repr__(self):
4091 
    L = ['%s=%r' % (key, value)
4092 
      for key, value in self.__dict__.iteritems()]
4093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4094 
 
4095 
  def __eq__(self, other):
4096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4097 
 
4098 
  def __ne__(self, other):
4099 
    return not (self == other)
4100 
 
483 rajveer 4101 
class getAllOrders_result:
94 ashish 4102 
  """
4103 
  Attributes:
4104 
   - success
4105 
   - ex
4106 
  """
4107 
 
4108 
  thrift_spec = (
483 rajveer 4109 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 4110 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4111 
  )
4112 
 
4113 
  def __init__(self, success=None, ex=None,):
4114 
    self.success = success
4115 
    self.ex = ex
4116 
 
4117 
  def read(self, iprot):
4118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4120 
      return
4121 
    iprot.readStructBegin()
4122 
    while True:
4123 
      (fname, ftype, fid) = iprot.readFieldBegin()
4124 
      if ftype == TType.STOP:
4125 
        break
4126 
      if fid == 0:
483 rajveer 4127 
        if ftype == TType.LIST:
4128 
          self.success = []
685 chandransh 4129 
          (_etype31, _size28) = iprot.readListBegin()
4130 
          for _i32 in xrange(_size28):
4131 
            _elem33 = Order()
4132 
            _elem33.read(iprot)
4133 
            self.success.append(_elem33)
483 rajveer 4134 
          iprot.readListEnd()
94 ashish 4135 
        else:
4136 
          iprot.skip(ftype)
4137 
      elif fid == 1:
4138 
        if ftype == TType.STRUCT:
4139 
          self.ex = TransactionServiceException()
4140 
          self.ex.read(iprot)
4141 
        else:
4142 
          iprot.skip(ftype)
4143 
      else:
4144 
        iprot.skip(ftype)
4145 
      iprot.readFieldEnd()
4146 
    iprot.readStructEnd()
4147 
 
4148 
  def write(self, oprot):
4149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4151 
      return
483 rajveer 4152 
    oprot.writeStructBegin('getAllOrders_result')
94 ashish 4153 
    if self.success != None:
483 rajveer 4154 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4155 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4156 
      for iter34 in self.success:
4157 
        iter34.write(oprot)
483 rajveer 4158 
      oprot.writeListEnd()
94 ashish 4159 
      oprot.writeFieldEnd()
4160 
    if self.ex != None:
4161 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4162 
      self.ex.write(oprot)
4163 
      oprot.writeFieldEnd()
4164 
    oprot.writeFieldStop()
4165 
    oprot.writeStructEnd()
4166 
 
4167 
  def __repr__(self):
4168 
    L = ['%s=%r' % (key, value)
4169 
      for key, value in self.__dict__.iteritems()]
4170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4171 
 
4172 
  def __eq__(self, other):
4173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4174 
 
4175 
  def __ne__(self, other):
4176 
    return not (self == other)
4177 
 
999 varun.gupt 4178 
class getOrdersByBillingDate_args:
4179 
  """
4180 
  Attributes:
4181 
   - status
4182 
   - start_billing_date
4183 
   - end_billing_date
4184 
   - warehouse_id
4185 
  """
4186 
 
4187 
  thrift_spec = (
4188 
    None, # 0
4189 
    (1, TType.I32, 'status', None, None, ), # 1
4190 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
4191 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
4192 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
4193 
  )
4194 
 
4195 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
4196 
    self.status = status
4197 
    self.start_billing_date = start_billing_date
4198 
    self.end_billing_date = end_billing_date
4199 
    self.warehouse_id = warehouse_id
4200 
 
4201 
  def read(self, iprot):
4202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4204 
      return
4205 
    iprot.readStructBegin()
4206 
    while True:
4207 
      (fname, ftype, fid) = iprot.readFieldBegin()
4208 
      if ftype == TType.STOP:
4209 
        break
4210 
      if fid == 1:
4211 
        if ftype == TType.I32:
4212 
          self.status = iprot.readI32();
4213 
        else:
4214 
          iprot.skip(ftype)
4215 
      elif fid == 2:
4216 
        if ftype == TType.I64:
4217 
          self.start_billing_date = iprot.readI64();
4218 
        else:
4219 
          iprot.skip(ftype)
4220 
      elif fid == 3:
4221 
        if ftype == TType.I64:
4222 
          self.end_billing_date = iprot.readI64();
4223 
        else:
4224 
          iprot.skip(ftype)
4225 
      elif fid == 4:
4226 
        if ftype == TType.I64:
4227 
          self.warehouse_id = iprot.readI64();
4228 
        else:
4229 
          iprot.skip(ftype)
4230 
      else:
4231 
        iprot.skip(ftype)
4232 
      iprot.readFieldEnd()
4233 
    iprot.readStructEnd()
4234 
 
4235 
  def write(self, oprot):
4236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4238 
      return
4239 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
4240 
    if self.status != None:
4241 
      oprot.writeFieldBegin('status', TType.I32, 1)
4242 
      oprot.writeI32(self.status)
4243 
      oprot.writeFieldEnd()
4244 
    if self.start_billing_date != None:
4245 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
4246 
      oprot.writeI64(self.start_billing_date)
4247 
      oprot.writeFieldEnd()
4248 
    if self.end_billing_date != None:
4249 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
4250 
      oprot.writeI64(self.end_billing_date)
4251 
      oprot.writeFieldEnd()
4252 
    if self.warehouse_id != None:
4253 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
4254 
      oprot.writeI64(self.warehouse_id)
4255 
      oprot.writeFieldEnd()
4256 
    oprot.writeFieldStop()
4257 
    oprot.writeStructEnd()
4258 
 
4259 
  def __repr__(self):
4260 
    L = ['%s=%r' % (key, value)
4261 
      for key, value in self.__dict__.iteritems()]
4262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4263 
 
4264 
  def __eq__(self, other):
4265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4266 
 
4267 
  def __ne__(self, other):
4268 
    return not (self == other)
4269 
 
4270 
class getOrdersByBillingDate_result:
4271 
  """
4272 
  Attributes:
4273 
   - success
4274 
   - ex
4275 
  """
4276 
 
4277 
  thrift_spec = (
4278 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
4279 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4280 
  )
4281 
 
4282 
  def __init__(self, success=None, ex=None,):
4283 
    self.success = success
4284 
    self.ex = ex
4285 
 
4286 
  def read(self, iprot):
4287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4289 
      return
4290 
    iprot.readStructBegin()
4291 
    while True:
4292 
      (fname, ftype, fid) = iprot.readFieldBegin()
4293 
      if ftype == TType.STOP:
4294 
        break
4295 
      if fid == 0:
4296 
        if ftype == TType.LIST:
4297 
          self.success = []
4298 
          (_etype38, _size35) = iprot.readListBegin()
4299 
          for _i39 in xrange(_size35):
4300 
            _elem40 = Order()
4301 
            _elem40.read(iprot)
4302 
            self.success.append(_elem40)
4303 
          iprot.readListEnd()
4304 
        else:
4305 
          iprot.skip(ftype)
4306 
      elif fid == 1:
4307 
        if ftype == TType.STRUCT:
4308 
          self.ex = TransactionServiceException()
4309 
          self.ex.read(iprot)
4310 
        else:
4311 
          iprot.skip(ftype)
4312 
      else:
4313 
        iprot.skip(ftype)
4314 
      iprot.readFieldEnd()
4315 
    iprot.readStructEnd()
4316 
 
4317 
  def write(self, oprot):
4318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4320 
      return
4321 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
4322 
    if self.success != None:
4323 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4324 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4325 
      for iter41 in self.success:
4326 
        iter41.write(oprot)
4327 
      oprot.writeListEnd()
4328 
      oprot.writeFieldEnd()
4329 
    if self.ex != None:
4330 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4331 
      self.ex.write(oprot)
4332 
      oprot.writeFieldEnd()
4333 
    oprot.writeFieldStop()
4334 
    oprot.writeStructEnd()
4335 
 
4336 
  def __repr__(self):
4337 
    L = ['%s=%r' % (key, value)
4338 
      for key, value in self.__dict__.iteritems()]
4339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4340 
 
4341 
  def __eq__(self, other):
4342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4343 
 
4344 
  def __ne__(self, other):
4345 
    return not (self == other)
4346 
 
1382 varun.gupt 4347 
class getReturnableOrdersForCustomer_args:
4348 
  """
4349 
  Attributes:
4350 
   - customer_id
4351 
   - limit
4352 
  """
4353 
 
4354 
  thrift_spec = (
4355 
    None, # 0
4356 
    (1, TType.I64, 'customer_id', None, None, ), # 1
4357 
    (2, TType.I64, 'limit', None, None, ), # 2
4358 
  )
4359 
 
4360 
  def __init__(self, customer_id=None, limit=None,):
4361 
    self.customer_id = customer_id
4362 
    self.limit = limit
4363 
 
4364 
  def read(self, iprot):
4365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4367 
      return
4368 
    iprot.readStructBegin()
4369 
    while True:
4370 
      (fname, ftype, fid) = iprot.readFieldBegin()
4371 
      if ftype == TType.STOP:
4372 
        break
4373 
      if fid == 1:
4374 
        if ftype == TType.I64:
4375 
          self.customer_id = iprot.readI64();
4376 
        else:
4377 
          iprot.skip(ftype)
4378 
      elif fid == 2:
4379 
        if ftype == TType.I64:
4380 
          self.limit = iprot.readI64();
4381 
        else:
4382 
          iprot.skip(ftype)
4383 
      else:
4384 
        iprot.skip(ftype)
4385 
      iprot.readFieldEnd()
4386 
    iprot.readStructEnd()
4387 
 
4388 
  def write(self, oprot):
4389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4391 
      return
4392 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
4393 
    if self.customer_id != None:
4394 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
4395 
      oprot.writeI64(self.customer_id)
4396 
      oprot.writeFieldEnd()
4397 
    if self.limit != None:
4398 
      oprot.writeFieldBegin('limit', TType.I64, 2)
4399 
      oprot.writeI64(self.limit)
4400 
      oprot.writeFieldEnd()
4401 
    oprot.writeFieldStop()
4402 
    oprot.writeStructEnd()
4403 
 
4404 
  def __repr__(self):
4405 
    L = ['%s=%r' % (key, value)
4406 
      for key, value in self.__dict__.iteritems()]
4407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4408 
 
4409 
  def __eq__(self, other):
4410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4411 
 
4412 
  def __ne__(self, other):
4413 
    return not (self == other)
4414 
 
4415 
class getReturnableOrdersForCustomer_result:
4416 
  """
4417 
  Attributes:
4418 
   - success
4419 
   - ex
4420 
  """
4421 
 
4422 
  thrift_spec = (
4423 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
4424 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4425 
  )
4426 
 
4427 
  def __init__(self, success=None, ex=None,):
4428 
    self.success = success
4429 
    self.ex = ex
4430 
 
4431 
  def read(self, iprot):
4432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4434 
      return
4435 
    iprot.readStructBegin()
4436 
    while True:
4437 
      (fname, ftype, fid) = iprot.readFieldBegin()
4438 
      if ftype == TType.STOP:
4439 
        break
4440 
      if fid == 0:
4441 
        if ftype == TType.LIST:
4442 
          self.success = []
4443 
          (_etype45, _size42) = iprot.readListBegin()
4444 
          for _i46 in xrange(_size42):
4445 
            _elem47 = iprot.readI64();
4446 
            self.success.append(_elem47)
4447 
          iprot.readListEnd()
4448 
        else:
4449 
          iprot.skip(ftype)
4450 
      elif fid == 1:
4451 
        if ftype == TType.STRUCT:
4452 
          self.ex = TransactionServiceException()
4453 
          self.ex.read(iprot)
4454 
        else:
4455 
          iprot.skip(ftype)
4456 
      else:
4457 
        iprot.skip(ftype)
4458 
      iprot.readFieldEnd()
4459 
    iprot.readStructEnd()
4460 
 
4461 
  def write(self, oprot):
4462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4464 
      return
4465 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
4466 
    if self.success != None:
4467 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4468 
      oprot.writeListBegin(TType.I64, len(self.success))
4469 
      for iter48 in self.success:
4470 
        oprot.writeI64(iter48)
4471 
      oprot.writeListEnd()
4472 
      oprot.writeFieldEnd()
4473 
    if self.ex != None:
4474 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4475 
      self.ex.write(oprot)
4476 
      oprot.writeFieldEnd()
4477 
    oprot.writeFieldStop()
4478 
    oprot.writeStructEnd()
4479 
 
4480 
  def __repr__(self):
4481 
    L = ['%s=%r' % (key, value)
4482 
      for key, value in self.__dict__.iteritems()]
4483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4484 
 
4485 
  def __eq__(self, other):
4486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4487 
 
4488 
  def __ne__(self, other):
4489 
    return not (self == other)
4490 
 
4491 
class getCancellableOrdersForCustomer_args:
4492 
  """
4493 
  Attributes:
4494 
   - customer_id
4495 
   - limit
4496 
  """
4497 
 
4498 
  thrift_spec = (
4499 
    None, # 0
4500 
    (1, TType.I64, 'customer_id', None, None, ), # 1
4501 
    (2, TType.I64, 'limit', None, None, ), # 2
4502 
  )
4503 
 
4504 
  def __init__(self, customer_id=None, limit=None,):
4505 
    self.customer_id = customer_id
4506 
    self.limit = limit
4507 
 
4508 
  def read(self, iprot):
4509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4511 
      return
4512 
    iprot.readStructBegin()
4513 
    while True:
4514 
      (fname, ftype, fid) = iprot.readFieldBegin()
4515 
      if ftype == TType.STOP:
4516 
        break
4517 
      if fid == 1:
4518 
        if ftype == TType.I64:
4519 
          self.customer_id = iprot.readI64();
4520 
        else:
4521 
          iprot.skip(ftype)
4522 
      elif fid == 2:
4523 
        if ftype == TType.I64:
4524 
          self.limit = iprot.readI64();
4525 
        else:
4526 
          iprot.skip(ftype)
4527 
      else:
4528 
        iprot.skip(ftype)
4529 
      iprot.readFieldEnd()
4530 
    iprot.readStructEnd()
4531 
 
4532 
  def write(self, oprot):
4533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4535 
      return
4536 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
4537 
    if self.customer_id != None:
4538 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
4539 
      oprot.writeI64(self.customer_id)
4540 
      oprot.writeFieldEnd()
4541 
    if self.limit != None:
4542 
      oprot.writeFieldBegin('limit', TType.I64, 2)
4543 
      oprot.writeI64(self.limit)
4544 
      oprot.writeFieldEnd()
4545 
    oprot.writeFieldStop()
4546 
    oprot.writeStructEnd()
4547 
 
4548 
  def __repr__(self):
4549 
    L = ['%s=%r' % (key, value)
4550 
      for key, value in self.__dict__.iteritems()]
4551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4552 
 
4553 
  def __eq__(self, other):
4554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4555 
 
4556 
  def __ne__(self, other):
4557 
    return not (self == other)
4558 
 
4559 
class getCancellableOrdersForCustomer_result:
4560 
  """
4561 
  Attributes:
4562 
   - success
4563 
   - ex
4564 
  """
4565 
 
4566 
  thrift_spec = (
4567 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
4568 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4569 
  )
4570 
 
4571 
  def __init__(self, success=None, ex=None,):
4572 
    self.success = success
4573 
    self.ex = ex
4574 
 
4575 
  def read(self, iprot):
4576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4578 
      return
4579 
    iprot.readStructBegin()
4580 
    while True:
4581 
      (fname, ftype, fid) = iprot.readFieldBegin()
4582 
      if ftype == TType.STOP:
4583 
        break
4584 
      if fid == 0:
4585 
        if ftype == TType.LIST:
4586 
          self.success = []
4587 
          (_etype52, _size49) = iprot.readListBegin()
4588 
          for _i53 in xrange(_size49):
4589 
            _elem54 = iprot.readI64();
4590 
            self.success.append(_elem54)
4591 
          iprot.readListEnd()
4592 
        else:
4593 
          iprot.skip(ftype)
4594 
      elif fid == 1:
4595 
        if ftype == TType.STRUCT:
4596 
          self.ex = TransactionServiceException()
4597 
          self.ex.read(iprot)
4598 
        else:
4599 
          iprot.skip(ftype)
4600 
      else:
4601 
        iprot.skip(ftype)
4602 
      iprot.readFieldEnd()
4603 
    iprot.readStructEnd()
4604 
 
4605 
  def write(self, oprot):
4606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4608 
      return
4609 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
4610 
    if self.success != None:
4611 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4612 
      oprot.writeListBegin(TType.I64, len(self.success))
4613 
      for iter55 in self.success:
4614 
        oprot.writeI64(iter55)
4615 
      oprot.writeListEnd()
4616 
      oprot.writeFieldEnd()
4617 
    if self.ex != None:
4618 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4619 
      self.ex.write(oprot)
4620 
      oprot.writeFieldEnd()
4621 
    oprot.writeFieldStop()
4622 
    oprot.writeStructEnd()
4623 
 
4624 
  def __repr__(self):
4625 
    L = ['%s=%r' % (key, value)
4626 
      for key, value in self.__dict__.iteritems()]
4627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4628 
 
4629 
  def __eq__(self, other):
4630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4631 
 
4632 
  def __ne__(self, other):
4633 
    return not (self == other)
4634 
 
483 rajveer 4635 
class changeOrderStatus_args:
94 ashish 4636 
  """
4637 
  Attributes:
483 rajveer 4638 
   - orderId
4639 
   - status
4640 
   - description
94 ashish 4641 
  """
4642 
 
4643 
  thrift_spec = (
4644 
    None, # 0
483 rajveer 4645 
    (1, TType.I64, 'orderId', None, None, ), # 1
4646 
    (2, TType.I32, 'status', None, None, ), # 2
4647 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 4648 
  )
4649 
 
483 rajveer 4650 
  def __init__(self, orderId=None, status=None, description=None,):
4651 
    self.orderId = orderId
4652 
    self.status = status
4653 
    self.description = description
94 ashish 4654 
 
4655 
  def read(self, iprot):
4656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4658 
      return
4659 
    iprot.readStructBegin()
4660 
    while True:
4661 
      (fname, ftype, fid) = iprot.readFieldBegin()
4662 
      if ftype == TType.STOP:
4663 
        break
4664 
      if fid == 1:
4665 
        if ftype == TType.I64:
483 rajveer 4666 
          self.orderId = iprot.readI64();
94 ashish 4667 
        else:
4668 
          iprot.skip(ftype)
4669 
      elif fid == 2:
483 rajveer 4670 
        if ftype == TType.I32:
4671 
          self.status = iprot.readI32();
94 ashish 4672 
        else:
4673 
          iprot.skip(ftype)
483 rajveer 4674 
      elif fid == 3:
4675 
        if ftype == TType.STRING:
4676 
          self.description = iprot.readString();
4677 
        else:
4678 
          iprot.skip(ftype)
94 ashish 4679 
      else:
4680 
        iprot.skip(ftype)
4681 
      iprot.readFieldEnd()
4682 
    iprot.readStructEnd()
4683 
 
4684 
  def write(self, oprot):
4685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4687 
      return
483 rajveer 4688 
    oprot.writeStructBegin('changeOrderStatus_args')
4689 
    if self.orderId != None:
4690 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4691 
      oprot.writeI64(self.orderId)
94 ashish 4692 
      oprot.writeFieldEnd()
483 rajveer 4693 
    if self.status != None:
4694 
      oprot.writeFieldBegin('status', TType.I32, 2)
4695 
      oprot.writeI32(self.status)
94 ashish 4696 
      oprot.writeFieldEnd()
483 rajveer 4697 
    if self.description != None:
4698 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4699 
      oprot.writeString(self.description)
4700 
      oprot.writeFieldEnd()
94 ashish 4701 
    oprot.writeFieldStop()
4702 
    oprot.writeStructEnd()
4703 
 
4704 
  def __repr__(self):
4705 
    L = ['%s=%r' % (key, value)
4706 
      for key, value in self.__dict__.iteritems()]
4707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4708 
 
4709 
  def __eq__(self, other):
4710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4711 
 
4712 
  def __ne__(self, other):
4713 
    return not (self == other)
4714 
 
483 rajveer 4715 
class changeOrderStatus_result:
94 ashish 4716 
  """
4717 
  Attributes:
4718 
   - success
4719 
   - ex
4720 
  """
4721 
 
4722 
  thrift_spec = (
4723 
    (0, TType.BOOL, 'success', None, None, ), # 0
4724 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4725 
  )
4726 
 
4727 
  def __init__(self, success=None, ex=None,):
4728 
    self.success = success
4729 
    self.ex = ex
4730 
 
4731 
  def read(self, iprot):
4732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4734 
      return
4735 
    iprot.readStructBegin()
4736 
    while True:
4737 
      (fname, ftype, fid) = iprot.readFieldBegin()
4738 
      if ftype == TType.STOP:
4739 
        break
4740 
      if fid == 0:
4741 
        if ftype == TType.BOOL:
4742 
          self.success = iprot.readBool();
4743 
        else:
4744 
          iprot.skip(ftype)
4745 
      elif fid == 1:
4746 
        if ftype == TType.STRUCT:
4747 
          self.ex = TransactionServiceException()
4748 
          self.ex.read(iprot)
4749 
        else:
4750 
          iprot.skip(ftype)
4751 
      else:
4752 
        iprot.skip(ftype)
4753 
      iprot.readFieldEnd()
4754 
    iprot.readStructEnd()
4755 
 
4756 
  def write(self, oprot):
4757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4759 
      return
483 rajveer 4760 
    oprot.writeStructBegin('changeOrderStatus_result')
94 ashish 4761 
    if self.success != None:
4762 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4763 
      oprot.writeBool(self.success)
4764 
      oprot.writeFieldEnd()
4765 
    if self.ex != None:
4766 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4767 
      self.ex.write(oprot)
4768 
      oprot.writeFieldEnd()
4769 
    oprot.writeFieldStop()
4770 
    oprot.writeStructEnd()
4771 
 
4772 
  def __repr__(self):
4773 
    L = ['%s=%r' % (key, value)
4774 
      for key, value in self.__dict__.iteritems()]
4775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4776 
 
4777 
  def __eq__(self, other):
4778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4779 
 
4780 
  def __ne__(self, other):
4781 
    return not (self == other)
4782 
 
494 rajveer 4783 
class addBillingDetails_args:
4784 
  """
4785 
  Attributes:
4786 
   - orderId
4787 
   - invoice_number
4788 
   - billed_by
4789 
  """
4790 
 
4791 
  thrift_spec = (
4792 
    None, # 0
4793 
    (1, TType.I64, 'orderId', None, None, ), # 1
4794 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
1149 chandransh 4795 
    (3, TType.STRING, 'billed_by', None, None, ), # 3
494 rajveer 4796 
  )
4797 
 
1149 chandransh 4798 
  def __init__(self, orderId=None, invoice_number=None, billed_by=None,):
494 rajveer 4799 
    self.orderId = orderId
4800 
    self.invoice_number = invoice_number
4801 
    self.billed_by = billed_by
4802 
 
4803 
  def read(self, iprot):
4804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4806 
      return
4807 
    iprot.readStructBegin()
4808 
    while True:
4809 
      (fname, ftype, fid) = iprot.readFieldBegin()
4810 
      if ftype == TType.STOP:
4811 
        break
4812 
      if fid == 1:
4813 
        if ftype == TType.I64:
4814 
          self.orderId = iprot.readI64();
4815 
        else:
4816 
          iprot.skip(ftype)
4817 
      elif fid == 2:
4818 
        if ftype == TType.STRING:
4819 
          self.invoice_number = iprot.readString();
4820 
        else:
4821 
          iprot.skip(ftype)
4822 
      elif fid == 3:
4823 
        if ftype == TType.STRING:
4824 
          self.billed_by = iprot.readString();
4825 
        else:
4826 
          iprot.skip(ftype)
4827 
      else:
4828 
        iprot.skip(ftype)
4829 
      iprot.readFieldEnd()
4830 
    iprot.readStructEnd()
4831 
 
4832 
  def write(self, oprot):
4833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4835 
      return
4836 
    oprot.writeStructBegin('addBillingDetails_args')
4837 
    if self.orderId != None:
4838 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4839 
      oprot.writeI64(self.orderId)
4840 
      oprot.writeFieldEnd()
4841 
    if self.invoice_number != None:
4842 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
4843 
      oprot.writeString(self.invoice_number)
4844 
      oprot.writeFieldEnd()
4845 
    if self.billed_by != None:
1149 chandransh 4846 
      oprot.writeFieldBegin('billed_by', TType.STRING, 3)
494 rajveer 4847 
      oprot.writeString(self.billed_by)
4848 
      oprot.writeFieldEnd()
4849 
    oprot.writeFieldStop()
4850 
    oprot.writeStructEnd()
4851 
 
4852 
  def __repr__(self):
4853 
    L = ['%s=%r' % (key, value)
4854 
      for key, value in self.__dict__.iteritems()]
4855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4856 
 
4857 
  def __eq__(self, other):
4858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4859 
 
4860 
  def __ne__(self, other):
4861 
    return not (self == other)
4862 
 
4863 
class addBillingDetails_result:
4864 
  """
4865 
  Attributes:
4866 
   - success
4867 
   - ex
4868 
  """
4869 
 
4870 
  thrift_spec = (
4871 
    (0, TType.BOOL, 'success', None, None, ), # 0
4872 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4873 
  )
4874 
 
4875 
  def __init__(self, success=None, ex=None,):
4876 
    self.success = success
4877 
    self.ex = ex
4878 
 
4879 
  def read(self, iprot):
4880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4882 
      return
4883 
    iprot.readStructBegin()
4884 
    while True:
4885 
      (fname, ftype, fid) = iprot.readFieldBegin()
4886 
      if ftype == TType.STOP:
4887 
        break
4888 
      if fid == 0:
4889 
        if ftype == TType.BOOL:
4890 
          self.success = iprot.readBool();
4891 
        else:
4892 
          iprot.skip(ftype)
4893 
      elif fid == 1:
4894 
        if ftype == TType.STRUCT:
4895 
          self.ex = TransactionServiceException()
4896 
          self.ex.read(iprot)
4897 
        else:
4898 
          iprot.skip(ftype)
4899 
      else:
4900 
        iprot.skip(ftype)
4901 
      iprot.readFieldEnd()
4902 
    iprot.readStructEnd()
4903 
 
4904 
  def write(self, oprot):
4905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4907 
      return
4908 
    oprot.writeStructBegin('addBillingDetails_result')
4909 
    if self.success != None:
4910 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4911 
      oprot.writeBool(self.success)
4912 
      oprot.writeFieldEnd()
4913 
    if self.ex != None:
4914 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4915 
      self.ex.write(oprot)
4916 
      oprot.writeFieldEnd()
4917 
    oprot.writeFieldStop()
4918 
    oprot.writeStructEnd()
4919 
 
4920 
  def __repr__(self):
4921 
    L = ['%s=%r' % (key, value)
4922 
      for key, value in self.__dict__.iteritems()]
4923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4924 
 
4925 
  def __eq__(self, other):
4926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4927 
 
4928 
  def __ne__(self, other):
4929 
    return not (self == other)
4930 
 
1149 chandransh 4931 
class addJacketNumber_args:
4932 
  """
4933 
  Attributes:
4934 
   - orderId
4935 
   - jacketNumber
2783 chandransh 4936 
   - imeiNumber
4937 
   - itemNumber
4938 
   - billedBy
2842 chandransh 4939 
   - billingType
1149 chandransh 4940 
  """
4941 
 
4942 
  thrift_spec = (
4943 
    None, # 0
4944 
    (1, TType.I64, 'orderId', None, None, ), # 1
4945 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
2783 chandransh 4946 
    (3, TType.I64, 'imeiNumber', None, None, ), # 3
4947 
    (4, TType.STRING, 'itemNumber', None, None, ), # 4
4948 
    (5, TType.STRING, 'billedBy', None, None, ), # 5
2842 chandransh 4949 
    (6, TType.I64, 'billingType', None, None, ), # 6
1149 chandransh 4950 
  )
4951 
 
2842 chandransh 4952 
  def __init__(self, orderId=None, jacketNumber=None, imeiNumber=None, itemNumber=None, billedBy=None, billingType=None,):
1149 chandransh 4953 
    self.orderId = orderId
4954 
    self.jacketNumber = jacketNumber
2783 chandransh 4955 
    self.imeiNumber = imeiNumber
4956 
    self.itemNumber = itemNumber
4957 
    self.billedBy = billedBy
2842 chandransh 4958 
    self.billingType = billingType
1149 chandransh 4959 
 
4960 
  def read(self, iprot):
4961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4963 
      return
4964 
    iprot.readStructBegin()
4965 
    while True:
4966 
      (fname, ftype, fid) = iprot.readFieldBegin()
4967 
      if ftype == TType.STOP:
4968 
        break
4969 
      if fid == 1:
4970 
        if ftype == TType.I64:
4971 
          self.orderId = iprot.readI64();
4972 
        else:
4973 
          iprot.skip(ftype)
4974 
      elif fid == 2:
4975 
        if ftype == TType.I64:
4976 
          self.jacketNumber = iprot.readI64();
4977 
        else:
4978 
          iprot.skip(ftype)
2783 chandransh 4979 
      elif fid == 3:
4980 
        if ftype == TType.I64:
4981 
          self.imeiNumber = iprot.readI64();
4982 
        else:
4983 
          iprot.skip(ftype)
4984 
      elif fid == 4:
4985 
        if ftype == TType.STRING:
4986 
          self.itemNumber = iprot.readString();
4987 
        else:
4988 
          iprot.skip(ftype)
4989 
      elif fid == 5:
4990 
        if ftype == TType.STRING:
4991 
          self.billedBy = iprot.readString();
4992 
        else:
4993 
          iprot.skip(ftype)
2842 chandransh 4994 
      elif fid == 6:
4995 
        if ftype == TType.I64:
4996 
          self.billingType = iprot.readI64();
4997 
        else:
4998 
          iprot.skip(ftype)
1149 chandransh 4999 
      else:
5000 
        iprot.skip(ftype)
5001 
      iprot.readFieldEnd()
5002 
    iprot.readStructEnd()
5003 
 
5004 
  def write(self, oprot):
5005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5007 
      return
5008 
    oprot.writeStructBegin('addJacketNumber_args')
5009 
    if self.orderId != None:
5010 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5011 
      oprot.writeI64(self.orderId)
5012 
      oprot.writeFieldEnd()
5013 
    if self.jacketNumber != None:
5014 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
5015 
      oprot.writeI64(self.jacketNumber)
5016 
      oprot.writeFieldEnd()
2783 chandransh 5017 
    if self.imeiNumber != None:
5018 
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
5019 
      oprot.writeI64(self.imeiNumber)
5020 
      oprot.writeFieldEnd()
5021 
    if self.itemNumber != None:
5022 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
5023 
      oprot.writeString(self.itemNumber)
5024 
      oprot.writeFieldEnd()
5025 
    if self.billedBy != None:
5026 
      oprot.writeFieldBegin('billedBy', TType.STRING, 5)
5027 
      oprot.writeString(self.billedBy)
5028 
      oprot.writeFieldEnd()
2842 chandransh 5029 
    if self.billingType != None:
5030 
      oprot.writeFieldBegin('billingType', TType.I64, 6)
5031 
      oprot.writeI64(self.billingType)
5032 
      oprot.writeFieldEnd()
1149 chandransh 5033 
    oprot.writeFieldStop()
5034 
    oprot.writeStructEnd()
5035 
 
5036 
  def __repr__(self):
5037 
    L = ['%s=%r' % (key, value)
5038 
      for key, value in self.__dict__.iteritems()]
5039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5040 
 
5041 
  def __eq__(self, other):
5042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5043 
 
5044 
  def __ne__(self, other):
5045 
    return not (self == other)
5046 
 
5047 
class addJacketNumber_result:
5048 
  """
5049 
  Attributes:
5050 
   - success
5051 
   - ex
5052 
  """
5053 
 
5054 
  thrift_spec = (
5055 
    (0, TType.BOOL, 'success', None, None, ), # 0
5056 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5057 
  )
5058 
 
5059 
  def __init__(self, success=None, ex=None,):
5060 
    self.success = success
5061 
    self.ex = ex
5062 
 
5063 
  def read(self, iprot):
5064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5066 
      return
5067 
    iprot.readStructBegin()
5068 
    while True:
5069 
      (fname, ftype, fid) = iprot.readFieldBegin()
5070 
      if ftype == TType.STOP:
5071 
        break
5072 
      if fid == 0:
5073 
        if ftype == TType.BOOL:
5074 
          self.success = iprot.readBool();
5075 
        else:
5076 
          iprot.skip(ftype)
5077 
      elif fid == 1:
5078 
        if ftype == TType.STRUCT:
5079 
          self.ex = TransactionServiceException()
5080 
          self.ex.read(iprot)
5081 
        else:
5082 
          iprot.skip(ftype)
5083 
      else:
5084 
        iprot.skip(ftype)
5085 
      iprot.readFieldEnd()
5086 
    iprot.readStructEnd()
5087 
 
5088 
  def write(self, oprot):
5089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5091 
      return
5092 
    oprot.writeStructBegin('addJacketNumber_result')
5093 
    if self.success != None:
5094 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5095 
      oprot.writeBool(self.success)
5096 
      oprot.writeFieldEnd()
5097 
    if self.ex != None:
5098 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5099 
      self.ex.write(oprot)
5100 
      oprot.writeFieldEnd()
5101 
    oprot.writeFieldStop()
5102 
    oprot.writeStructEnd()
5103 
 
5104 
  def __repr__(self):
5105 
    L = ['%s=%r' % (key, value)
5106 
      for key, value in self.__dict__.iteritems()]
5107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5108 
 
5109 
  def __eq__(self, other):
5110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5111 
 
5112 
  def __ne__(self, other):
5113 
    return not (self == other)
5114 
 
921 rajveer 5115 
class acceptOrder_args:
5116 
  """
5117 
  Attributes:
5118 
   - orderId
5119 
  """
5120 
 
5121 
  thrift_spec = (
5122 
    None, # 0
5123 
    (1, TType.I64, 'orderId', None, None, ), # 1
5124 
  )
5125 
 
5126 
  def __init__(self, orderId=None,):
5127 
    self.orderId = orderId
5128 
 
5129 
  def read(self, iprot):
5130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5132 
      return
5133 
    iprot.readStructBegin()
5134 
    while True:
5135 
      (fname, ftype, fid) = iprot.readFieldBegin()
5136 
      if ftype == TType.STOP:
5137 
        break
5138 
      if fid == 1:
5139 
        if ftype == TType.I64:
5140 
          self.orderId = iprot.readI64();
5141 
        else:
5142 
          iprot.skip(ftype)
5143 
      else:
5144 
        iprot.skip(ftype)
5145 
      iprot.readFieldEnd()
5146 
    iprot.readStructEnd()
5147 
 
5148 
  def write(self, oprot):
5149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5151 
      return
5152 
    oprot.writeStructBegin('acceptOrder_args')
5153 
    if self.orderId != None:
5154 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5155 
      oprot.writeI64(self.orderId)
5156 
      oprot.writeFieldEnd()
5157 
    oprot.writeFieldStop()
5158 
    oprot.writeStructEnd()
5159 
 
5160 
  def __repr__(self):
5161 
    L = ['%s=%r' % (key, value)
5162 
      for key, value in self.__dict__.iteritems()]
5163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5164 
 
5165 
  def __eq__(self, other):
5166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5167 
 
5168 
  def __ne__(self, other):
5169 
    return not (self == other)
5170 
 
5171 
class acceptOrder_result:
5172 
  """
5173 
  Attributes:
5174 
   - success
5175 
   - ex
5176 
  """
5177 
 
5178 
  thrift_spec = (
5179 
    (0, TType.BOOL, 'success', None, None, ), # 0
5180 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5181 
  )
5182 
 
5183 
  def __init__(self, success=None, ex=None,):
5184 
    self.success = success
5185 
    self.ex = ex
5186 
 
5187 
  def read(self, iprot):
5188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5190 
      return
5191 
    iprot.readStructBegin()
5192 
    while True:
5193 
      (fname, ftype, fid) = iprot.readFieldBegin()
5194 
      if ftype == TType.STOP:
5195 
        break
5196 
      if fid == 0:
5197 
        if ftype == TType.BOOL:
5198 
          self.success = iprot.readBool();
5199 
        else:
5200 
          iprot.skip(ftype)
5201 
      elif fid == 1:
5202 
        if ftype == TType.STRUCT:
5203 
          self.ex = TransactionServiceException()
5204 
          self.ex.read(iprot)
5205 
        else:
5206 
          iprot.skip(ftype)
5207 
      else:
5208 
        iprot.skip(ftype)
5209 
      iprot.readFieldEnd()
5210 
    iprot.readStructEnd()
5211 
 
5212 
  def write(self, oprot):
5213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5215 
      return
5216 
    oprot.writeStructBegin('acceptOrder_result')
5217 
    if self.success != None:
5218 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5219 
      oprot.writeBool(self.success)
5220 
      oprot.writeFieldEnd()
5221 
    if self.ex != None:
5222 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5223 
      self.ex.write(oprot)
5224 
      oprot.writeFieldEnd()
5225 
    oprot.writeFieldStop()
5226 
    oprot.writeStructEnd()
5227 
 
5228 
  def __repr__(self):
5229 
    L = ['%s=%r' % (key, value)
5230 
      for key, value in self.__dict__.iteritems()]
5231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5232 
 
5233 
  def __eq__(self, other):
5234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5235 
 
5236 
  def __ne__(self, other):
5237 
    return not (self == other)
5238 
 
5239 
class billOrder_args:
5240 
  """
5241 
  Attributes:
5242 
   - orderId
5243 
  """
5244 
 
5245 
  thrift_spec = (
5246 
    None, # 0
5247 
    (1, TType.I64, 'orderId', None, None, ), # 1
5248 
  )
5249 
 
5250 
  def __init__(self, orderId=None,):
5251 
    self.orderId = orderId
5252 
 
5253 
  def read(self, iprot):
5254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5256 
      return
5257 
    iprot.readStructBegin()
5258 
    while True:
5259 
      (fname, ftype, fid) = iprot.readFieldBegin()
5260 
      if ftype == TType.STOP:
5261 
        break
5262 
      if fid == 1:
5263 
        if ftype == TType.I64:
5264 
          self.orderId = iprot.readI64();
5265 
        else:
5266 
          iprot.skip(ftype)
5267 
      else:
5268 
        iprot.skip(ftype)
5269 
      iprot.readFieldEnd()
5270 
    iprot.readStructEnd()
5271 
 
5272 
  def write(self, oprot):
5273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5275 
      return
5276 
    oprot.writeStructBegin('billOrder_args')
5277 
    if self.orderId != None:
5278 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5279 
      oprot.writeI64(self.orderId)
5280 
      oprot.writeFieldEnd()
5281 
    oprot.writeFieldStop()
5282 
    oprot.writeStructEnd()
5283 
 
5284 
  def __repr__(self):
5285 
    L = ['%s=%r' % (key, value)
5286 
      for key, value in self.__dict__.iteritems()]
5287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5288 
 
5289 
  def __eq__(self, other):
5290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5291 
 
5292 
  def __ne__(self, other):
5293 
    return not (self == other)
5294 
 
5295 
class billOrder_result:
5296 
  """
5297 
  Attributes:
5298 
   - success
5299 
   - ex
5300 
  """
5301 
 
5302 
  thrift_spec = (
5303 
    (0, TType.BOOL, 'success', None, None, ), # 0
5304 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5305 
  )
5306 
 
5307 
  def __init__(self, success=None, ex=None,):
5308 
    self.success = success
5309 
    self.ex = ex
5310 
 
5311 
  def read(self, iprot):
5312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5314 
      return
5315 
    iprot.readStructBegin()
5316 
    while True:
5317 
      (fname, ftype, fid) = iprot.readFieldBegin()
5318 
      if ftype == TType.STOP:
5319 
        break
5320 
      if fid == 0:
5321 
        if ftype == TType.BOOL:
5322 
          self.success = iprot.readBool();
5323 
        else:
5324 
          iprot.skip(ftype)
5325 
      elif fid == 1:
5326 
        if ftype == TType.STRUCT:
5327 
          self.ex = TransactionServiceException()
5328 
          self.ex.read(iprot)
5329 
        else:
5330 
          iprot.skip(ftype)
5331 
      else:
5332 
        iprot.skip(ftype)
5333 
      iprot.readFieldEnd()
5334 
    iprot.readStructEnd()
5335 
 
5336 
  def write(self, oprot):
5337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5339 
      return
5340 
    oprot.writeStructBegin('billOrder_result')
5341 
    if self.success != None:
5342 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5343 
      oprot.writeBool(self.success)
5344 
      oprot.writeFieldEnd()
5345 
    if self.ex != None:
5346 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5347 
      self.ex.write(oprot)
5348 
      oprot.writeFieldEnd()
5349 
    oprot.writeFieldStop()
5350 
    oprot.writeStructEnd()
5351 
 
5352 
  def __repr__(self):
5353 
    L = ['%s=%r' % (key, value)
5354 
      for key, value in self.__dict__.iteritems()]
5355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5356 
 
5357 
  def __eq__(self, other):
5358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5359 
 
5360 
  def __ne__(self, other):
5361 
    return not (self == other)
5362 
 
483 rajveer 5363 
class getOrdersForTransaction_args:
94 ashish 5364 
  """
5365 
  Attributes:
5366 
   - transactionId
1528 ankur.sing 5367 
   - customerId
94 ashish 5368 
  """
5369 
 
5370 
  thrift_spec = (
5371 
    None, # 0
5372 
    (1, TType.I64, 'transactionId', None, None, ), # 1
1528 ankur.sing 5373 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 5374 
  )
5375 
 
1528 ankur.sing 5376 
  def __init__(self, transactionId=None, customerId=None,):
94 ashish 5377 
    self.transactionId = transactionId
1528 ankur.sing 5378 
    self.customerId = customerId
94 ashish 5379 
 
5380 
  def read(self, iprot):
5381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5383 
      return
5384 
    iprot.readStructBegin()
5385 
    while True:
5386 
      (fname, ftype, fid) = iprot.readFieldBegin()
5387 
      if ftype == TType.STOP:
5388 
        break
5389 
      if fid == 1:
5390 
        if ftype == TType.I64:
5391 
          self.transactionId = iprot.readI64();
5392 
        else:
5393 
          iprot.skip(ftype)
1528 ankur.sing 5394 
      elif fid == 2:
5395 
        if ftype == TType.I64:
5396 
          self.customerId = iprot.readI64();
5397 
        else:
5398 
          iprot.skip(ftype)
94 ashish 5399 
      else:
5400 
        iprot.skip(ftype)
5401 
      iprot.readFieldEnd()
5402 
    iprot.readStructEnd()
5403 
 
5404 
  def write(self, oprot):
5405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5407 
      return
483 rajveer 5408 
    oprot.writeStructBegin('getOrdersForTransaction_args')
94 ashish 5409 
    if self.transactionId != None:
5410 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5411 
      oprot.writeI64(self.transactionId)
5412 
      oprot.writeFieldEnd()
1528 ankur.sing 5413 
    if self.customerId != None:
5414 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
5415 
      oprot.writeI64(self.customerId)
5416 
      oprot.writeFieldEnd()
94 ashish 5417 
    oprot.writeFieldStop()
5418 
    oprot.writeStructEnd()
5419 
 
5420 
  def __repr__(self):
5421 
    L = ['%s=%r' % (key, value)
5422 
      for key, value in self.__dict__.iteritems()]
5423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5424 
 
5425 
  def __eq__(self, other):
5426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5427 
 
5428 
  def __ne__(self, other):
5429 
    return not (self == other)
5430 
 
483 rajveer 5431 
class getOrdersForTransaction_result:
94 ashish 5432 
  """
5433 
  Attributes:
5434 
   - success
5435 
   - ex
5436 
  """
5437 
 
5438 
  thrift_spec = (
483 rajveer 5439 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5440 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5441 
  )
5442 
 
5443 
  def __init__(self, success=None, ex=None,):
5444 
    self.success = success
5445 
    self.ex = ex
5446 
 
5447 
  def read(self, iprot):
5448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5450 
      return
5451 
    iprot.readStructBegin()
5452 
    while True:
5453 
      (fname, ftype, fid) = iprot.readFieldBegin()
5454 
      if ftype == TType.STOP:
5455 
        break
5456 
      if fid == 0:
483 rajveer 5457 
        if ftype == TType.LIST:
5458 
          self.success = []
1382 varun.gupt 5459 
          (_etype59, _size56) = iprot.readListBegin()
5460 
          for _i60 in xrange(_size56):
5461 
            _elem61 = Order()
5462 
            _elem61.read(iprot)
5463 
            self.success.append(_elem61)
483 rajveer 5464 
          iprot.readListEnd()
94 ashish 5465 
        else:
5466 
          iprot.skip(ftype)
5467 
      elif fid == 1:
5468 
        if ftype == TType.STRUCT:
5469 
          self.ex = TransactionServiceException()
5470 
          self.ex.read(iprot)
5471 
        else:
5472 
          iprot.skip(ftype)
5473 
      else:
5474 
        iprot.skip(ftype)
5475 
      iprot.readFieldEnd()
5476 
    iprot.readStructEnd()
5477 
 
5478 
  def write(self, oprot):
5479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5481 
      return
483 rajveer 5482 
    oprot.writeStructBegin('getOrdersForTransaction_result')
94 ashish 5483 
    if self.success != None:
483 rajveer 5484 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5485 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1382 varun.gupt 5486 
      for iter62 in self.success:
5487 
        iter62.write(oprot)
483 rajveer 5488 
      oprot.writeListEnd()
94 ashish 5489 
      oprot.writeFieldEnd()
5490 
    if self.ex != None:
5491 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5492 
      self.ex.write(oprot)
5493 
      oprot.writeFieldEnd()
5494 
    oprot.writeFieldStop()
5495 
    oprot.writeStructEnd()
5496 
 
5497 
  def __repr__(self):
5498 
    L = ['%s=%r' % (key, value)
5499 
      for key, value in self.__dict__.iteritems()]
5500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5501 
 
5502 
  def __eq__(self, other):
5503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5504 
 
5505 
  def __ne__(self, other):
5506 
    return not (self == other)
5507 
 
483 rajveer 5508 
class getOrdersForCustomer_args:
94 ashish 5509 
  """
5510 
  Attributes:
483 rajveer 5511 
   - customerId
5512 
   - from_date
5513 
   - to_date
3014 chandransh 5514 
   - statuses
94 ashish 5515 
  """
5516 
 
5517 
  thrift_spec = (
5518 
    None, # 0
483 rajveer 5519 
    (1, TType.I64, 'customerId', None, None, ), # 1
5520 
    (2, TType.I64, 'from_date', None, None, ), # 2
5521 
    (3, TType.I64, 'to_date', None, None, ), # 3
3014 chandransh 5522 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
94 ashish 5523 
  )
5524 
 
3014 chandransh 5525 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
483 rajveer 5526 
    self.customerId = customerId
5527 
    self.from_date = from_date
5528 
    self.to_date = to_date
3014 chandransh 5529 
    self.statuses = statuses
94 ashish 5530 
 
5531 
  def read(self, iprot):
5532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5534 
      return
5535 
    iprot.readStructBegin()
5536 
    while True:
5537 
      (fname, ftype, fid) = iprot.readFieldBegin()
5538 
      if ftype == TType.STOP:
5539 
        break
5540 
      if fid == 1:
5541 
        if ftype == TType.I64:
483 rajveer 5542 
          self.customerId = iprot.readI64();
94 ashish 5543 
        else:
5544 
          iprot.skip(ftype)
5545 
      elif fid == 2:
5546 
        if ftype == TType.I64:
483 rajveer 5547 
          self.from_date = iprot.readI64();
94 ashish 5548 
        else:
5549 
          iprot.skip(ftype)
5550 
      elif fid == 3:
5551 
        if ftype == TType.I64:
483 rajveer 5552 
          self.to_date = iprot.readI64();
94 ashish 5553 
        else:
5554 
          iprot.skip(ftype)
483 rajveer 5555 
      elif fid == 4:
3014 chandransh 5556 
        if ftype == TType.LIST:
5557 
          self.statuses = []
5558 
          (_etype66, _size63) = iprot.readListBegin()
5559 
          for _i67 in xrange(_size63):
5560 
            _elem68 = iprot.readI32();
5561 
            self.statuses.append(_elem68)
5562 
          iprot.readListEnd()
483 rajveer 5563 
        else:
5564 
          iprot.skip(ftype)
94 ashish 5565 
      else:
5566 
        iprot.skip(ftype)
5567 
      iprot.readFieldEnd()
5568 
    iprot.readStructEnd()
5569 
 
5570 
  def write(self, oprot):
5571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5573 
      return
483 rajveer 5574 
    oprot.writeStructBegin('getOrdersForCustomer_args')
5575 
    if self.customerId != None:
5576 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
5577 
      oprot.writeI64(self.customerId)
94 ashish 5578 
      oprot.writeFieldEnd()
483 rajveer 5579 
    if self.from_date != None:
5580 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5581 
      oprot.writeI64(self.from_date)
94 ashish 5582 
      oprot.writeFieldEnd()
483 rajveer 5583 
    if self.to_date != None:
5584 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5585 
      oprot.writeI64(self.to_date)
94 ashish 5586 
      oprot.writeFieldEnd()
3014 chandransh 5587 
    if self.statuses != None:
5588 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
5589 
      oprot.writeListBegin(TType.I32, len(self.statuses))
5590 
      for iter69 in self.statuses:
5591 
        oprot.writeI32(iter69)
5592 
      oprot.writeListEnd()
483 rajveer 5593 
      oprot.writeFieldEnd()
94 ashish 5594 
    oprot.writeFieldStop()
5595 
    oprot.writeStructEnd()
5596 
 
5597 
  def __repr__(self):
5598 
    L = ['%s=%r' % (key, value)
5599 
      for key, value in self.__dict__.iteritems()]
5600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5601 
 
5602 
  def __eq__(self, other):
5603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5604 
 
5605 
  def __ne__(self, other):
5606 
    return not (self == other)
5607 
 
483 rajveer 5608 
class getOrdersForCustomer_result:
94 ashish 5609 
  """
5610 
  Attributes:
5611 
   - success
5612 
   - ex
5613 
  """
5614 
 
5615 
  thrift_spec = (
483 rajveer 5616 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5617 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5618 
  )
5619 
 
5620 
  def __init__(self, success=None, ex=None,):
5621 
    self.success = success
5622 
    self.ex = ex
5623 
 
5624 
  def read(self, iprot):
5625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5627 
      return
5628 
    iprot.readStructBegin()
5629 
    while True:
5630 
      (fname, ftype, fid) = iprot.readFieldBegin()
5631 
      if ftype == TType.STOP:
5632 
        break
5633 
      if fid == 0:
483 rajveer 5634 
        if ftype == TType.LIST:
5635 
          self.success = []
3014 chandransh 5636 
          (_etype73, _size70) = iprot.readListBegin()
5637 
          for _i74 in xrange(_size70):
5638 
            _elem75 = Order()
5639 
            _elem75.read(iprot)
5640 
            self.success.append(_elem75)
483 rajveer 5641 
          iprot.readListEnd()
94 ashish 5642 
        else:
5643 
          iprot.skip(ftype)
5644 
      elif fid == 1:
5645 
        if ftype == TType.STRUCT:
5646 
          self.ex = TransactionServiceException()
5647 
          self.ex.read(iprot)
5648 
        else:
5649 
          iprot.skip(ftype)
5650 
      else:
5651 
        iprot.skip(ftype)
5652 
      iprot.readFieldEnd()
5653 
    iprot.readStructEnd()
5654 
 
5655 
  def write(self, oprot):
5656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5658 
      return
483 rajveer 5659 
    oprot.writeStructBegin('getOrdersForCustomer_result')
94 ashish 5660 
    if self.success != None:
483 rajveer 5661 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5662 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3014 chandransh 5663 
      for iter76 in self.success:
5664 
        iter76.write(oprot)
483 rajveer 5665 
      oprot.writeListEnd()
94 ashish 5666 
      oprot.writeFieldEnd()
5667 
    if self.ex != None:
5668 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5669 
      self.ex.write(oprot)
5670 
      oprot.writeFieldEnd()
5671 
    oprot.writeFieldStop()
5672 
    oprot.writeStructEnd()
5673 
 
5674 
  def __repr__(self):
5675 
    L = ['%s=%r' % (key, value)
5676 
      for key, value in self.__dict__.iteritems()]
5677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5678 
 
5679 
  def __eq__(self, other):
5680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5681 
 
5682 
  def __ne__(self, other):
5683 
    return not (self == other)
5684 
 
483 rajveer 5685 
class createOrder_args:
94 ashish 5686 
  """
5687 
  Attributes:
483 rajveer 5688 
   - order
94 ashish 5689 
  """
5690 
 
5691 
  thrift_spec = (
5692 
    None, # 0
483 rajveer 5693 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
94 ashish 5694 
  )
5695 
 
483 rajveer 5696 
  def __init__(self, order=None,):
5697 
    self.order = order
94 ashish 5698 
 
5699 
  def read(self, iprot):
5700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5702 
      return
5703 
    iprot.readStructBegin()
5704 
    while True:
5705 
      (fname, ftype, fid) = iprot.readFieldBegin()
5706 
      if ftype == TType.STOP:
5707 
        break
5708 
      if fid == 1:
483 rajveer 5709 
        if ftype == TType.STRUCT:
5710 
          self.order = Order()
5711 
          self.order.read(iprot)
94 ashish 5712 
        else:
5713 
          iprot.skip(ftype)
5714 
      else:
5715 
        iprot.skip(ftype)
5716 
      iprot.readFieldEnd()
5717 
    iprot.readStructEnd()
5718 
 
5719 
  def write(self, oprot):
5720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5722 
      return
483 rajveer 5723 
    oprot.writeStructBegin('createOrder_args')
5724 
    if self.order != None:
5725 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
5726 
      self.order.write(oprot)
94 ashish 5727 
      oprot.writeFieldEnd()
5728 
    oprot.writeFieldStop()
5729 
    oprot.writeStructEnd()
5730 
 
5731 
  def __repr__(self):
5732 
    L = ['%s=%r' % (key, value)
5733 
      for key, value in self.__dict__.iteritems()]
5734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5735 
 
5736 
  def __eq__(self, other):
5737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5738 
 
5739 
  def __ne__(self, other):
5740 
    return not (self == other)
5741 
 
483 rajveer 5742 
class createOrder_result:
94 ashish 5743 
  """
5744 
  Attributes:
5745 
   - success
5746 
   - ex
5747 
  """
5748 
 
5749 
  thrift_spec = (
483 rajveer 5750 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5751 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5752 
  )
5753 
 
5754 
  def __init__(self, success=None, ex=None,):
5755 
    self.success = success
5756 
    self.ex = ex
5757 
 
5758 
  def read(self, iprot):
5759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5761 
      return
5762 
    iprot.readStructBegin()
5763 
    while True:
5764 
      (fname, ftype, fid) = iprot.readFieldBegin()
5765 
      if ftype == TType.STOP:
5766 
        break
5767 
      if fid == 0:
483 rajveer 5768 
        if ftype == TType.I64:
5769 
          self.success = iprot.readI64();
94 ashish 5770 
        else:
5771 
          iprot.skip(ftype)
5772 
      elif fid == 1:
5773 
        if ftype == TType.STRUCT:
5774 
          self.ex = TransactionServiceException()
5775 
          self.ex.read(iprot)
5776 
        else:
5777 
          iprot.skip(ftype)
5778 
      else:
5779 
        iprot.skip(ftype)
5780 
      iprot.readFieldEnd()
5781 
    iprot.readStructEnd()
5782 
 
5783 
  def write(self, oprot):
5784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5786 
      return
483 rajveer 5787 
    oprot.writeStructBegin('createOrder_result')
94 ashish 5788 
    if self.success != None:
483 rajveer 5789 
      oprot.writeFieldBegin('success', TType.I64, 0)
5790 
      oprot.writeI64(self.success)
94 ashish 5791 
      oprot.writeFieldEnd()
5792 
    if self.ex != None:
5793 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5794 
      self.ex.write(oprot)
5795 
      oprot.writeFieldEnd()
5796 
    oprot.writeFieldStop()
5797 
    oprot.writeStructEnd()
5798 
 
5799 
  def __repr__(self):
5800 
    L = ['%s=%r' % (key, value)
5801 
      for key, value in self.__dict__.iteritems()]
5802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5803 
 
5804 
  def __eq__(self, other):
5805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5806 
 
5807 
  def __ne__(self, other):
5808 
    return not (self == other)
5809 
 
483 rajveer 5810 
class getOrder_args:
94 ashish 5811 
  """
5812 
  Attributes:
483 rajveer 5813 
   - id
94 ashish 5814 
  """
5815 
 
5816 
  thrift_spec = (
5817 
    None, # 0
483 rajveer 5818 
    (1, TType.I64, 'id', None, None, ), # 1
94 ashish 5819 
  )
5820 
 
483 rajveer 5821 
  def __init__(self, id=None,):
5822 
    self.id = id
94 ashish 5823 
 
5824 
  def read(self, iprot):
5825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5827 
      return
5828 
    iprot.readStructBegin()
5829 
    while True:
5830 
      (fname, ftype, fid) = iprot.readFieldBegin()
5831 
      if ftype == TType.STOP:
5832 
        break
5833 
      if fid == 1:
5834 
        if ftype == TType.I64:
483 rajveer 5835 
          self.id = iprot.readI64();
94 ashish 5836 
        else:
5837 
          iprot.skip(ftype)
5838 
      else:
5839 
        iprot.skip(ftype)
5840 
      iprot.readFieldEnd()
5841 
    iprot.readStructEnd()
5842 
 
5843 
  def write(self, oprot):
5844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5846 
      return
483 rajveer 5847 
    oprot.writeStructBegin('getOrder_args')
5848 
    if self.id != None:
5849 
      oprot.writeFieldBegin('id', TType.I64, 1)
5850 
      oprot.writeI64(self.id)
94 ashish 5851 
      oprot.writeFieldEnd()
5852 
    oprot.writeFieldStop()
5853 
    oprot.writeStructEnd()
5854 
 
5855 
  def __repr__(self):
5856 
    L = ['%s=%r' % (key, value)
5857 
      for key, value in self.__dict__.iteritems()]
5858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5859 
 
5860 
  def __eq__(self, other):
5861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5862 
 
5863 
  def __ne__(self, other):
5864 
    return not (self == other)
5865 
 
483 rajveer 5866 
class getOrder_result:
94 ashish 5867 
  """
5868 
  Attributes:
5869 
   - success
5870 
   - ex
5871 
  """
5872 
 
5873 
  thrift_spec = (
483 rajveer 5874 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 5875 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5876 
  )
5877 
 
5878 
  def __init__(self, success=None, ex=None,):
5879 
    self.success = success
5880 
    self.ex = ex
5881 
 
5882 
  def read(self, iprot):
5883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5885 
      return
5886 
    iprot.readStructBegin()
5887 
    while True:
5888 
      (fname, ftype, fid) = iprot.readFieldBegin()
5889 
      if ftype == TType.STOP:
5890 
        break
5891 
      if fid == 0:
483 rajveer 5892 
        if ftype == TType.STRUCT:
5893 
          self.success = Order()
5894 
          self.success.read(iprot)
94 ashish 5895 
        else:
5896 
          iprot.skip(ftype)
5897 
      elif fid == 1:
5898 
        if ftype == TType.STRUCT:
5899 
          self.ex = TransactionServiceException()
5900 
          self.ex.read(iprot)
5901 
        else:
5902 
          iprot.skip(ftype)
5903 
      else:
5904 
        iprot.skip(ftype)
5905 
      iprot.readFieldEnd()
5906 
    iprot.readStructEnd()
5907 
 
5908 
  def write(self, oprot):
5909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5911 
      return
483 rajveer 5912 
    oprot.writeStructBegin('getOrder_result')
94 ashish 5913 
    if self.success != None:
483 rajveer 5914 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5915 
      self.success.write(oprot)
94 ashish 5916 
      oprot.writeFieldEnd()
5917 
    if self.ex != None:
5918 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5919 
      self.ex.write(oprot)
5920 
      oprot.writeFieldEnd()
5921 
    oprot.writeFieldStop()
5922 
    oprot.writeStructEnd()
5923 
 
5924 
  def __repr__(self):
5925 
    L = ['%s=%r' % (key, value)
5926 
      for key, value in self.__dict__.iteritems()]
5927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5928 
 
5929 
  def __eq__(self, other):
5930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5931 
 
5932 
  def __ne__(self, other):
5933 
    return not (self == other)
5934 
 
483 rajveer 5935 
class getLineItemsForOrder_args:
94 ashish 5936 
  """
5937 
  Attributes:
483 rajveer 5938 
   - orderId
94 ashish 5939 
  """
5940 
 
5941 
  thrift_spec = (
5942 
    None, # 0
483 rajveer 5943 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 5944 
  )
5945 
 
483 rajveer 5946 
  def __init__(self, orderId=None,):
5947 
    self.orderId = orderId
94 ashish 5948 
 
5949 
  def read(self, iprot):
5950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5952 
      return
5953 
    iprot.readStructBegin()
5954 
    while True:
5955 
      (fname, ftype, fid) = iprot.readFieldBegin()
5956 
      if ftype == TType.STOP:
5957 
        break
5958 
      if fid == 1:
5959 
        if ftype == TType.I64:
483 rajveer 5960 
          self.orderId = iprot.readI64();
94 ashish 5961 
        else:
5962 
          iprot.skip(ftype)
5963 
      else:
5964 
        iprot.skip(ftype)
5965 
      iprot.readFieldEnd()
5966 
    iprot.readStructEnd()
5967 
 
5968 
  def write(self, oprot):
5969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5971 
      return
483 rajveer 5972 
    oprot.writeStructBegin('getLineItemsForOrder_args')
5973 
    if self.orderId != None:
5974 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5975 
      oprot.writeI64(self.orderId)
94 ashish 5976 
      oprot.writeFieldEnd()
5977 
    oprot.writeFieldStop()
5978 
    oprot.writeStructEnd()
5979 
 
5980 
  def __repr__(self):
5981 
    L = ['%s=%r' % (key, value)
5982 
      for key, value in self.__dict__.iteritems()]
5983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5984 
 
5985 
  def __eq__(self, other):
5986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5987 
 
5988 
  def __ne__(self, other):
5989 
    return not (self == other)
5990 
 
483 rajveer 5991 
class getLineItemsForOrder_result:
94 ashish 5992 
  """
5993 
  Attributes:
5994 
   - success
5995 
   - ex
5996 
  """
5997 
 
5998 
  thrift_spec = (
483 rajveer 5999 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 6000 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6001 
  )
6002 
 
6003 
  def __init__(self, success=None, ex=None,):
6004 
    self.success = success
6005 
    self.ex = ex
6006 
 
6007 
  def read(self, iprot):
6008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6010 
      return
6011 
    iprot.readStructBegin()
6012 
    while True:
6013 
      (fname, ftype, fid) = iprot.readFieldBegin()
6014 
      if ftype == TType.STOP:
6015 
        break
6016 
      if fid == 0:
483 rajveer 6017 
        if ftype == TType.LIST:
6018 
          self.success = []
3014 chandransh 6019 
          (_etype80, _size77) = iprot.readListBegin()
6020 
          for _i81 in xrange(_size77):
6021 
            _elem82 = LineItem()
6022 
            _elem82.read(iprot)
6023 
            self.success.append(_elem82)
483 rajveer 6024 
          iprot.readListEnd()
94 ashish 6025 
        else:
6026 
          iprot.skip(ftype)
6027 
      elif fid == 1:
6028 
        if ftype == TType.STRUCT:
6029 
          self.ex = TransactionServiceException()
6030 
          self.ex.read(iprot)
6031 
        else:
6032 
          iprot.skip(ftype)
6033 
      else:
6034 
        iprot.skip(ftype)
6035 
      iprot.readFieldEnd()
6036 
    iprot.readStructEnd()
6037 
 
6038 
  def write(self, oprot):
6039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6041 
      return
483 rajveer 6042 
    oprot.writeStructBegin('getLineItemsForOrder_result')
94 ashish 6043 
    if self.success != None:
483 rajveer 6044 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6045 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3014 chandransh 6046 
      for iter83 in self.success:
6047 
        iter83.write(oprot)
483 rajveer 6048 
      oprot.writeListEnd()
94 ashish 6049 
      oprot.writeFieldEnd()
6050 
    if self.ex != None:
6051 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6052 
      self.ex.write(oprot)
6053 
      oprot.writeFieldEnd()
6054 
    oprot.writeFieldStop()
6055 
    oprot.writeStructEnd()
6056 
 
6057 
  def __repr__(self):
6058 
    L = ['%s=%r' % (key, value)
6059 
      for key, value in self.__dict__.iteritems()]
6060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6061 
 
6062 
  def __eq__(self, other):
6063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6064 
 
6065 
  def __ne__(self, other):
6066 
    return not (self == other)
6067 
 
1528 ankur.sing 6068 
class getOrderForCustomer_args:
6069 
  """
6070 
  Attributes:
6071 
   - orderId
6072 
   - customerId
6073 
  """
6074 
 
6075 
  thrift_spec = (
6076 
    None, # 0
6077 
    (1, TType.I64, 'orderId', None, None, ), # 1
6078 
    (2, TType.I64, 'customerId', None, None, ), # 2
6079 
  )
6080 
 
6081 
  def __init__(self, orderId=None, customerId=None,):
6082 
    self.orderId = orderId
6083 
    self.customerId = customerId
6084 
 
6085 
  def read(self, iprot):
6086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6088 
      return
6089 
    iprot.readStructBegin()
6090 
    while True:
6091 
      (fname, ftype, fid) = iprot.readFieldBegin()
6092 
      if ftype == TType.STOP:
6093 
        break
6094 
      if fid == 1:
6095 
        if ftype == TType.I64:
6096 
          self.orderId = iprot.readI64();
6097 
        else:
6098 
          iprot.skip(ftype)
6099 
      elif fid == 2:
6100 
        if ftype == TType.I64:
6101 
          self.customerId = iprot.readI64();
6102 
        else:
6103 
          iprot.skip(ftype)
6104 
      else:
6105 
        iprot.skip(ftype)
6106 
      iprot.readFieldEnd()
6107 
    iprot.readStructEnd()
6108 
 
6109 
  def write(self, oprot):
6110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6112 
      return
6113 
    oprot.writeStructBegin('getOrderForCustomer_args')
6114 
    if self.orderId != None:
6115 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6116 
      oprot.writeI64(self.orderId)
6117 
      oprot.writeFieldEnd()
6118 
    if self.customerId != None:
6119 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
6120 
      oprot.writeI64(self.customerId)
6121 
      oprot.writeFieldEnd()
6122 
    oprot.writeFieldStop()
6123 
    oprot.writeStructEnd()
6124 
 
6125 
  def __repr__(self):
6126 
    L = ['%s=%r' % (key, value)
6127 
      for key, value in self.__dict__.iteritems()]
6128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6129 
 
6130 
  def __eq__(self, other):
6131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6132 
 
6133 
  def __ne__(self, other):
6134 
    return not (self == other)
6135 
 
6136 
class getOrderForCustomer_result:
6137 
  """
6138 
  Attributes:
6139 
   - success
6140 
   - ex
6141 
  """
6142 
 
6143 
  thrift_spec = (
6144 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
6145 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6146 
  )
6147 
 
6148 
  def __init__(self, success=None, ex=None,):
6149 
    self.success = success
6150 
    self.ex = ex
6151 
 
6152 
  def read(self, iprot):
6153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6155 
      return
6156 
    iprot.readStructBegin()
6157 
    while True:
6158 
      (fname, ftype, fid) = iprot.readFieldBegin()
6159 
      if ftype == TType.STOP:
6160 
        break
6161 
      if fid == 0:
6162 
        if ftype == TType.STRUCT:
6163 
          self.success = Order()
6164 
          self.success.read(iprot)
6165 
        else:
6166 
          iprot.skip(ftype)
6167 
      elif fid == 1:
6168 
        if ftype == TType.STRUCT:
6169 
          self.ex = TransactionServiceException()
6170 
          self.ex.read(iprot)
6171 
        else:
6172 
          iprot.skip(ftype)
6173 
      else:
6174 
        iprot.skip(ftype)
6175 
      iprot.readFieldEnd()
6176 
    iprot.readStructEnd()
6177 
 
6178 
  def write(self, oprot):
6179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6181 
      return
6182 
    oprot.writeStructBegin('getOrderForCustomer_result')
6183 
    if self.success != None:
6184 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6185 
      self.success.write(oprot)
6186 
      oprot.writeFieldEnd()
6187 
    if self.ex != None:
6188 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6189 
      self.ex.write(oprot)
6190 
      oprot.writeFieldEnd()
6191 
    oprot.writeFieldStop()
6192 
    oprot.writeStructEnd()
6193 
 
6194 
  def __repr__(self):
6195 
    L = ['%s=%r' % (key, value)
6196 
      for key, value in self.__dict__.iteritems()]
6197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6198 
 
6199 
  def __eq__(self, other):
6200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6201 
 
6202 
  def __ne__(self, other):
6203 
    return not (self == other)
6204 
 
1220 chandransh 6205 
class batchOrders_args:
6206 
  """
6207 
  Attributes:
6208 
   - warehouseId
6209 
  """
6210 
 
6211 
  thrift_spec = (
6212 
    None, # 0
6213 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
6214 
  )
6215 
 
6216 
  def __init__(self, warehouseId=None,):
6217 
    self.warehouseId = warehouseId
6218 
 
6219 
  def read(self, iprot):
6220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6222 
      return
6223 
    iprot.readStructBegin()
6224 
    while True:
6225 
      (fname, ftype, fid) = iprot.readFieldBegin()
6226 
      if ftype == TType.STOP:
6227 
        break
6228 
      if fid == 1:
6229 
        if ftype == TType.I64:
6230 
          self.warehouseId = iprot.readI64();
6231 
        else:
6232 
          iprot.skip(ftype)
6233 
      else:
6234 
        iprot.skip(ftype)
6235 
      iprot.readFieldEnd()
6236 
    iprot.readStructEnd()
6237 
 
6238 
  def write(self, oprot):
6239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6241 
      return
6242 
    oprot.writeStructBegin('batchOrders_args')
6243 
    if self.warehouseId != None:
6244 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
6245 
      oprot.writeI64(self.warehouseId)
6246 
      oprot.writeFieldEnd()
6247 
    oprot.writeFieldStop()
6248 
    oprot.writeStructEnd()
6249 
 
6250 
  def __repr__(self):
6251 
    L = ['%s=%r' % (key, value)
6252 
      for key, value in self.__dict__.iteritems()]
6253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6254 
 
6255 
  def __eq__(self, other):
6256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6257 
 
6258 
  def __ne__(self, other):
6259 
    return not (self == other)
6260 
 
6261 
class batchOrders_result:
6262 
  """
6263 
  Attributes:
6264 
   - success
6265 
   - ex
6266 
  """
6267 
 
6268 
  thrift_spec = (
6269 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6270 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6271 
  )
6272 
 
6273 
  def __init__(self, success=None, ex=None,):
6274 
    self.success = success
6275 
    self.ex = ex
6276 
 
6277 
  def read(self, iprot):
6278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6280 
      return
6281 
    iprot.readStructBegin()
6282 
    while True:
6283 
      (fname, ftype, fid) = iprot.readFieldBegin()
6284 
      if ftype == TType.STOP:
6285 
        break
6286 
      if fid == 0:
6287 
        if ftype == TType.LIST:
6288 
          self.success = []
3014 chandransh 6289 
          (_etype87, _size84) = iprot.readListBegin()
6290 
          for _i88 in xrange(_size84):
6291 
            _elem89 = Order()
6292 
            _elem89.read(iprot)
6293 
            self.success.append(_elem89)
1220 chandransh 6294 
          iprot.readListEnd()
6295 
        else:
6296 
          iprot.skip(ftype)
6297 
      elif fid == 1:
6298 
        if ftype == TType.STRUCT:
6299 
          self.ex = TransactionServiceException()
6300 
          self.ex.read(iprot)
6301 
        else:
6302 
          iprot.skip(ftype)
6303 
      else:
6304 
        iprot.skip(ftype)
6305 
      iprot.readFieldEnd()
6306 
    iprot.readStructEnd()
6307 
 
6308 
  def write(self, oprot):
6309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6311 
      return
6312 
    oprot.writeStructBegin('batchOrders_result')
6313 
    if self.success != None:
6314 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6315 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3014 chandransh 6316 
      for iter90 in self.success:
6317 
        iter90.write(oprot)
1220 chandransh 6318 
      oprot.writeListEnd()
6319 
      oprot.writeFieldEnd()
6320 
    if self.ex != None:
6321 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6322 
      self.ex.write(oprot)
6323 
      oprot.writeFieldEnd()
6324 
    oprot.writeFieldStop()
6325 
    oprot.writeStructEnd()
6326 
 
6327 
  def __repr__(self):
6328 
    L = ['%s=%r' % (key, value)
6329 
      for key, value in self.__dict__.iteritems()]
6330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6331 
 
6332 
  def __eq__(self, other):
6333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6334 
 
6335 
  def __ne__(self, other):
6336 
    return not (self == other)
6337 
 
1208 chandransh 6338 
class markOrderAsOutOfStock_args:
6339 
  """
6340 
  Attributes:
6341 
   - orderId
6342 
  """
6343 
 
6344 
  thrift_spec = (
6345 
    None, # 0
6346 
    (1, TType.I64, 'orderId', None, None, ), # 1
6347 
  )
6348 
 
6349 
  def __init__(self, orderId=None,):
6350 
    self.orderId = orderId
6351 
 
6352 
  def read(self, iprot):
6353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6355 
      return
6356 
    iprot.readStructBegin()
6357 
    while True:
6358 
      (fname, ftype, fid) = iprot.readFieldBegin()
6359 
      if ftype == TType.STOP:
6360 
        break
6361 
      if fid == 1:
6362 
        if ftype == TType.I64:
6363 
          self.orderId = iprot.readI64();
6364 
        else:
6365 
          iprot.skip(ftype)
6366 
      else:
6367 
        iprot.skip(ftype)
6368 
      iprot.readFieldEnd()
6369 
    iprot.readStructEnd()
6370 
 
6371 
  def write(self, oprot):
6372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6374 
      return
6375 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
6376 
    if self.orderId != None:
6377 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6378 
      oprot.writeI64(self.orderId)
6379 
      oprot.writeFieldEnd()
6380 
    oprot.writeFieldStop()
6381 
    oprot.writeStructEnd()
6382 
 
6383 
  def __repr__(self):
6384 
    L = ['%s=%r' % (key, value)
6385 
      for key, value in self.__dict__.iteritems()]
6386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6387 
 
6388 
  def __eq__(self, other):
6389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6390 
 
6391 
  def __ne__(self, other):
6392 
    return not (self == other)
6393 
 
6394 
class markOrderAsOutOfStock_result:
6395 
  """
6396 
  Attributes:
6397 
   - success
6398 
   - ex
6399 
  """
6400 
 
6401 
  thrift_spec = (
6402 
    (0, TType.BOOL, 'success', None, None, ), # 0
6403 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6404 
  )
6405 
 
6406 
  def __init__(self, success=None, ex=None,):
6407 
    self.success = success
6408 
    self.ex = ex
6409 
 
6410 
  def read(self, iprot):
6411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6413 
      return
6414 
    iprot.readStructBegin()
6415 
    while True:
6416 
      (fname, ftype, fid) = iprot.readFieldBegin()
6417 
      if ftype == TType.STOP:
6418 
        break
6419 
      if fid == 0:
6420 
        if ftype == TType.BOOL:
6421 
          self.success = iprot.readBool();
6422 
        else:
6423 
          iprot.skip(ftype)
6424 
      elif fid == 1:
6425 
        if ftype == TType.STRUCT:
6426 
          self.ex = TransactionServiceException()
6427 
          self.ex.read(iprot)
6428 
        else:
6429 
          iprot.skip(ftype)
6430 
      else:
6431 
        iprot.skip(ftype)
6432 
      iprot.readFieldEnd()
6433 
    iprot.readStructEnd()
6434 
 
6435 
  def write(self, oprot):
6436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6438 
      return
6439 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
6440 
    if self.success != None:
6441 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6442 
      oprot.writeBool(self.success)
6443 
      oprot.writeFieldEnd()
6444 
    if self.ex != None:
6445 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6446 
      self.ex.write(oprot)
6447 
      oprot.writeFieldEnd()
6448 
    oprot.writeFieldStop()
6449 
    oprot.writeStructEnd()
6450 
 
6451 
  def __repr__(self):
6452 
    L = ['%s=%r' % (key, value)
6453 
      for key, value in self.__dict__.iteritems()]
6454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6455 
 
6456 
  def __eq__(self, other):
6457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6458 
 
6459 
  def __ne__(self, other):
6460 
    return not (self == other)
6461 
 
759 chandransh 6462 
class markOrdersAsManifested_args:
6463 
  """
6464 
  Attributes:
6465 
   - warehouseId
6466 
   - providerId
6467 
  """
6468 
 
6469 
  thrift_spec = (
6470 
    None, # 0
6471 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
6472 
    (2, TType.I64, 'providerId', None, None, ), # 2
6473 
  )
6474 
 
6475 
  def __init__(self, warehouseId=None, providerId=None,):
6476 
    self.warehouseId = warehouseId
6477 
    self.providerId = providerId
6478 
 
6479 
  def read(self, iprot):
6480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6482 
      return
6483 
    iprot.readStructBegin()
6484 
    while True:
6485 
      (fname, ftype, fid) = iprot.readFieldBegin()
6486 
      if ftype == TType.STOP:
6487 
        break
6488 
      if fid == 1:
6489 
        if ftype == TType.I64:
6490 
          self.warehouseId = iprot.readI64();
6491 
        else:
6492 
          iprot.skip(ftype)
6493 
      elif fid == 2:
6494 
        if ftype == TType.I64:
6495 
          self.providerId = iprot.readI64();
6496 
        else:
6497 
          iprot.skip(ftype)
6498 
      else:
6499 
        iprot.skip(ftype)
6500 
      iprot.readFieldEnd()
6501 
    iprot.readStructEnd()
6502 
 
6503 
  def write(self, oprot):
6504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6506 
      return
6507 
    oprot.writeStructBegin('markOrdersAsManifested_args')
6508 
    if self.warehouseId != None:
6509 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
6510 
      oprot.writeI64(self.warehouseId)
6511 
      oprot.writeFieldEnd()
6512 
    if self.providerId != None:
6513 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
6514 
      oprot.writeI64(self.providerId)
6515 
      oprot.writeFieldEnd()
6516 
    oprot.writeFieldStop()
6517 
    oprot.writeStructEnd()
6518 
 
6519 
  def __repr__(self):
6520 
    L = ['%s=%r' % (key, value)
6521 
      for key, value in self.__dict__.iteritems()]
6522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6523 
 
6524 
  def __eq__(self, other):
6525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6526 
 
6527 
  def __ne__(self, other):
6528 
    return not (self == other)
6529 
 
6530 
class markOrdersAsManifested_result:
6531 
  """
6532 
  Attributes:
6533 
   - success
6534 
   - ex
6535 
  """
6536 
 
6537 
  thrift_spec = (
6538 
    (0, TType.BOOL, 'success', None, None, ), # 0
6539 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6540 
  )
6541 
 
6542 
  def __init__(self, success=None, ex=None,):
6543 
    self.success = success
6544 
    self.ex = ex
6545 
 
6546 
  def read(self, iprot):
6547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6549 
      return
6550 
    iprot.readStructBegin()
6551 
    while True:
6552 
      (fname, ftype, fid) = iprot.readFieldBegin()
6553 
      if ftype == TType.STOP:
6554 
        break
6555 
      if fid == 0:
6556 
        if ftype == TType.BOOL:
6557 
          self.success = iprot.readBool();
6558 
        else:
6559 
          iprot.skip(ftype)
6560 
      elif fid == 1:
6561 
        if ftype == TType.STRUCT:
6562 
          self.ex = TransactionServiceException()
6563 
          self.ex.read(iprot)
6564 
        else:
6565 
          iprot.skip(ftype)
6566 
      else:
6567 
        iprot.skip(ftype)
6568 
      iprot.readFieldEnd()
6569 
    iprot.readStructEnd()
6570 
 
6571 
  def write(self, oprot):
6572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6574 
      return
6575 
    oprot.writeStructBegin('markOrdersAsManifested_result')
6576 
    if self.success != None:
6577 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6578 
      oprot.writeBool(self.success)
6579 
      oprot.writeFieldEnd()
6580 
    if self.ex != None:
6581 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6582 
      self.ex.write(oprot)
6583 
      oprot.writeFieldEnd()
6584 
    oprot.writeFieldStop()
6585 
    oprot.writeStructEnd()
6586 
 
6587 
  def __repr__(self):
6588 
    L = ['%s=%r' % (key, value)
6589 
      for key, value in self.__dict__.iteritems()]
6590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6591 
 
6592 
  def __eq__(self, other):
6593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6594 
 
6595 
  def __ne__(self, other):
6596 
    return not (self == other)
6597 
 
1113 chandransh 6598 
class markOrdersAsPickedUp_args:
6599 
  """
6600 
  Attributes:
6601 
   - providerId
6602 
   - pickupDetails
6603 
  """
6604 
 
6605 
  thrift_spec = (
6606 
    None, # 0
6607 
    (1, TType.I64, 'providerId', None, None, ), # 1
1246 chandransh 6608 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
1113 chandransh 6609 
  )
6610 
 
6611 
  def __init__(self, providerId=None, pickupDetails=None,):
6612 
    self.providerId = providerId
6613 
    self.pickupDetails = pickupDetails
6614 
 
6615 
  def read(self, iprot):
6616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6618 
      return
6619 
    iprot.readStructBegin()
6620 
    while True:
6621 
      (fname, ftype, fid) = iprot.readFieldBegin()
6622 
      if ftype == TType.STOP:
6623 
        break
6624 
      if fid == 1:
6625 
        if ftype == TType.I64:
6626 
          self.providerId = iprot.readI64();
6627 
        else:
6628 
          iprot.skip(ftype)
6629 
      elif fid == 2:
6630 
        if ftype == TType.MAP:
6631 
          self.pickupDetails = {}
3014 chandransh 6632 
          (_ktype92, _vtype93, _size91 ) = iprot.readMapBegin()
6633 
          for _i95 in xrange(_size91):
6634 
            _key96 = iprot.readString();
6635 
            _val97 = iprot.readString();
6636 
            self.pickupDetails[_key96] = _val97
1113 chandransh 6637 
          iprot.readMapEnd()
6638 
        else:
6639 
          iprot.skip(ftype)
6640 
      else:
6641 
        iprot.skip(ftype)
6642 
      iprot.readFieldEnd()
6643 
    iprot.readStructEnd()
6644 
 
6645 
  def write(self, oprot):
6646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6648 
      return
6649 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
6650 
    if self.providerId != None:
6651 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
6652 
      oprot.writeI64(self.providerId)
6653 
      oprot.writeFieldEnd()
6654 
    if self.pickupDetails != None:
6655 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
1246 chandransh 6656 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
3014 chandransh 6657 
      for kiter98,viter99 in self.pickupDetails.items():
6658 
        oprot.writeString(kiter98)
6659 
        oprot.writeString(viter99)
1113 chandransh 6660 
      oprot.writeMapEnd()
6661 
      oprot.writeFieldEnd()
6662 
    oprot.writeFieldStop()
6663 
    oprot.writeStructEnd()
6664 
 
6665 
  def __repr__(self):
6666 
    L = ['%s=%r' % (key, value)
6667 
      for key, value in self.__dict__.iteritems()]
6668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6669 
 
6670 
  def __eq__(self, other):
6671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6672 
 
6673 
  def __ne__(self, other):
6674 
    return not (self == other)
6675 
 
6676 
class markOrdersAsPickedUp_result:
6677 
  """
6678 
  Attributes:
6679 
   - success
6680 
   - ex
6681 
  """
6682 
 
6683 
  thrift_spec = (
6684 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6685 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6686 
  )
6687 
 
6688 
  def __init__(self, success=None, ex=None,):
6689 
    self.success = success
6690 
    self.ex = ex
6691 
 
6692 
  def read(self, iprot):
6693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6695 
      return
6696 
    iprot.readStructBegin()
6697 
    while True:
6698 
      (fname, ftype, fid) = iprot.readFieldBegin()
6699 
      if ftype == TType.STOP:
6700 
        break
6701 
      if fid == 0:
6702 
        if ftype == TType.LIST:
6703 
          self.success = []
3014 chandransh 6704 
          (_etype103, _size100) = iprot.readListBegin()
6705 
          for _i104 in xrange(_size100):
6706 
            _elem105 = Order()
6707 
            _elem105.read(iprot)
6708 
            self.success.append(_elem105)
1113 chandransh 6709 
          iprot.readListEnd()
6710 
        else:
6711 
          iprot.skip(ftype)
6712 
      elif fid == 1:
6713 
        if ftype == TType.STRUCT:
6714 
          self.ex = TransactionServiceException()
6715 
          self.ex.read(iprot)
6716 
        else:
6717 
          iprot.skip(ftype)
6718 
      else:
6719 
        iprot.skip(ftype)
6720 
      iprot.readFieldEnd()
6721 
    iprot.readStructEnd()
6722 
 
6723 
  def write(self, oprot):
6724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6726 
      return
6727 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
6728 
    if self.success != None:
6729 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6730 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3014 chandransh 6731 
      for iter106 in self.success:
6732 
        iter106.write(oprot)
1113 chandransh 6733 
      oprot.writeListEnd()
6734 
      oprot.writeFieldEnd()
6735 
    if self.ex != None:
6736 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6737 
      self.ex.write(oprot)
6738 
      oprot.writeFieldEnd()
6739 
    oprot.writeFieldStop()
6740 
    oprot.writeStructEnd()
6741 
 
6742 
  def __repr__(self):
6743 
    L = ['%s=%r' % (key, value)
6744 
      for key, value in self.__dict__.iteritems()]
6745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6746 
 
6747 
  def __eq__(self, other):
6748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6749 
 
6750 
  def __ne__(self, other):
6751 
    return not (self == other)
6752 
 
1132 chandransh 6753 
class markOrdersAsDelivered_args:
6754 
  """
6755 
  Attributes:
6756 
   - providerId
6757 
   - deliveredOrders
6758 
  """
6759 
 
6760 
  thrift_spec = (
6761 
    None, # 0
6762 
    (1, TType.I64, 'providerId', None, None, ), # 1
6763 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
6764 
  )
6765 
 
6766 
  def __init__(self, providerId=None, deliveredOrders=None,):
6767 
    self.providerId = providerId
6768 
    self.deliveredOrders = deliveredOrders
6769 
 
6770 
  def read(self, iprot):
6771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6773 
      return
6774 
    iprot.readStructBegin()
6775 
    while True:
6776 
      (fname, ftype, fid) = iprot.readFieldBegin()
6777 
      if ftype == TType.STOP:
6778 
        break
6779 
      if fid == 1:
6780 
        if ftype == TType.I64:
6781 
          self.providerId = iprot.readI64();
6782 
        else:
6783 
          iprot.skip(ftype)
6784 
      elif fid == 2:
6785 
        if ftype == TType.MAP:
6786 
          self.deliveredOrders = {}
3014 chandransh 6787 
          (_ktype108, _vtype109, _size107 ) = iprot.readMapBegin()
6788 
          for _i111 in xrange(_size107):
6789 
            _key112 = iprot.readString();
6790 
            _val113 = iprot.readString();
6791 
            self.deliveredOrders[_key112] = _val113
1132 chandransh 6792 
          iprot.readMapEnd()
6793 
        else:
6794 
          iprot.skip(ftype)
6795 
      else:
6796 
        iprot.skip(ftype)
6797 
      iprot.readFieldEnd()
6798 
    iprot.readStructEnd()
6799 
 
6800 
  def write(self, oprot):
6801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6803 
      return
6804 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
6805 
    if self.providerId != None:
6806 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
6807 
      oprot.writeI64(self.providerId)
6808 
      oprot.writeFieldEnd()
6809 
    if self.deliveredOrders != None:
6810 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
6811 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
3014 chandransh 6812 
      for kiter114,viter115 in self.deliveredOrders.items():
6813 
        oprot.writeString(kiter114)
6814 
        oprot.writeString(viter115)
1132 chandransh 6815 
      oprot.writeMapEnd()
6816 
      oprot.writeFieldEnd()
6817 
    oprot.writeFieldStop()
6818 
    oprot.writeStructEnd()
6819 
 
6820 
  def __repr__(self):
6821 
    L = ['%s=%r' % (key, value)
6822 
      for key, value in self.__dict__.iteritems()]
6823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6824 
 
6825 
  def __eq__(self, other):
6826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6827 
 
6828 
  def __ne__(self, other):
6829 
    return not (self == other)
6830 
 
6831 
class markOrdersAsDelivered_result:
6832 
  """
6833 
  Attributes:
6834 
   - ex
6835 
  """
6836 
 
6837 
  thrift_spec = (
6838 
    None, # 0
6839 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6840 
  )
6841 
 
6842 
  def __init__(self, ex=None,):
6843 
    self.ex = ex
6844 
 
6845 
  def read(self, iprot):
6846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6848 
      return
6849 
    iprot.readStructBegin()
6850 
    while True:
6851 
      (fname, ftype, fid) = iprot.readFieldBegin()
6852 
      if ftype == TType.STOP:
6853 
        break
6854 
      if fid == 1:
6855 
        if ftype == TType.STRUCT:
6856 
          self.ex = TransactionServiceException()
6857 
          self.ex.read(iprot)
6858 
        else:
6859 
          iprot.skip(ftype)
6860 
      else:
6861 
        iprot.skip(ftype)
6862 
      iprot.readFieldEnd()
6863 
    iprot.readStructEnd()
6864 
 
6865 
  def write(self, oprot):
6866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6868 
      return
6869 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
6870 
    if self.ex != None:
6871 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6872 
      self.ex.write(oprot)
6873 
      oprot.writeFieldEnd()
6874 
    oprot.writeFieldStop()
6875 
    oprot.writeStructEnd()
6876 
 
6877 
  def __repr__(self):
6878 
    L = ['%s=%r' % (key, value)
6879 
      for key, value in self.__dict__.iteritems()]
6880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6881 
 
6882 
  def __eq__(self, other):
6883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6884 
 
6885 
  def __ne__(self, other):
6886 
    return not (self == other)
6887 
 
1135 chandransh 6888 
class markOrdersAsFailed_args:
6889 
  """
6890 
  Attributes:
6891 
   - providerId
6892 
   - returnedOrders
6893 
  """
6894 
 
6895 
  thrift_spec = (
6896 
    None, # 0
6897 
    (1, TType.I64, 'providerId', None, None, ), # 1
6898 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
6899 
  )
6900 
 
6901 
  def __init__(self, providerId=None, returnedOrders=None,):
6902 
    self.providerId = providerId
6903 
    self.returnedOrders = returnedOrders
6904 
 
6905 
  def read(self, iprot):
6906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6908 
      return
6909 
    iprot.readStructBegin()
6910 
    while True:
6911 
      (fname, ftype, fid) = iprot.readFieldBegin()
6912 
      if ftype == TType.STOP:
6913 
        break
6914 
      if fid == 1:
6915 
        if ftype == TType.I64:
6916 
          self.providerId = iprot.readI64();
6917 
        else:
6918 
          iprot.skip(ftype)
6919 
      elif fid == 2:
6920 
        if ftype == TType.MAP:
6921 
          self.returnedOrders = {}
3014 chandransh 6922 
          (_ktype117, _vtype118, _size116 ) = iprot.readMapBegin()
6923 
          for _i120 in xrange(_size116):
6924 
            _key121 = iprot.readString();
6925 
            _val122 = iprot.readString();
6926 
            self.returnedOrders[_key121] = _val122
1135 chandransh 6927 
          iprot.readMapEnd()
6928 
        else:
6929 
          iprot.skip(ftype)
6930 
      else:
6931 
        iprot.skip(ftype)
6932 
      iprot.readFieldEnd()
6933 
    iprot.readStructEnd()
6934 
 
6935 
  def write(self, oprot):
6936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6938 
      return
6939 
    oprot.writeStructBegin('markOrdersAsFailed_args')
6940 
    if self.providerId != None:
6941 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
6942 
      oprot.writeI64(self.providerId)
6943 
      oprot.writeFieldEnd()
6944 
    if self.returnedOrders != None:
6945 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
6946 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
3014 chandransh 6947 
      for kiter123,viter124 in self.returnedOrders.items():
6948 
        oprot.writeString(kiter123)
6949 
        oprot.writeString(viter124)
1135 chandransh 6950 
      oprot.writeMapEnd()
6951 
      oprot.writeFieldEnd()
6952 
    oprot.writeFieldStop()
6953 
    oprot.writeStructEnd()
6954 
 
6955 
  def __repr__(self):
6956 
    L = ['%s=%r' % (key, value)
6957 
      for key, value in self.__dict__.iteritems()]
6958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6959 
 
6960 
  def __eq__(self, other):
6961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6962 
 
6963 
  def __ne__(self, other):
6964 
    return not (self == other)
6965 
 
6966 
class markOrdersAsFailed_result:
6967 
  """
6968 
  Attributes:
6969 
   - ex
6970 
  """
6971 
 
6972 
  thrift_spec = (
6973 
    None, # 0
6974 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6975 
  )
6976 
 
6977 
  def __init__(self, ex=None,):
6978 
    self.ex = ex
6979 
 
6980 
  def read(self, iprot):
6981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6983 
      return
6984 
    iprot.readStructBegin()
6985 
    while True:
6986 
      (fname, ftype, fid) = iprot.readFieldBegin()
6987 
      if ftype == TType.STOP:
6988 
        break
6989 
      if fid == 1:
6990 
        if ftype == TType.STRUCT:
6991 
          self.ex = TransactionServiceException()
6992 
          self.ex.read(iprot)
6993 
        else:
6994 
          iprot.skip(ftype)
6995 
      else:
6996 
        iprot.skip(ftype)
6997 
      iprot.readFieldEnd()
6998 
    iprot.readStructEnd()
6999 
 
7000 
  def write(self, oprot):
7001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7003 
      return
7004 
    oprot.writeStructBegin('markOrdersAsFailed_result')
7005 
    if self.ex != None:
7006 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7007 
      self.ex.write(oprot)
7008 
      oprot.writeFieldEnd()
7009 
    oprot.writeFieldStop()
7010 
    oprot.writeStructEnd()
7011 
 
7012 
  def __repr__(self):
7013 
    L = ['%s=%r' % (key, value)
7014 
      for key, value in self.__dict__.iteritems()]
7015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7016 
 
7017 
  def __eq__(self, other):
7018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7019 
 
7020 
  def __ne__(self, other):
7021 
    return not (self == other)
7022 
 
1246 chandransh 7023 
class updateNonDeliveryReason_args:
7024 
  """
7025 
  Attributes:
7026 
   - providerId
7027 
   - undeliveredOrders
7028 
  """
7029 
 
7030 
  thrift_spec = (
7031 
    None, # 0
7032 
    (1, TType.I64, 'providerId', None, None, ), # 1
7033 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
7034 
  )
7035 
 
7036 
  def __init__(self, providerId=None, undeliveredOrders=None,):
7037 
    self.providerId = providerId
7038 
    self.undeliveredOrders = undeliveredOrders
7039 
 
7040 
  def read(self, iprot):
7041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7043 
      return
7044 
    iprot.readStructBegin()
7045 
    while True:
7046 
      (fname, ftype, fid) = iprot.readFieldBegin()
7047 
      if ftype == TType.STOP:
7048 
        break
7049 
      if fid == 1:
7050 
        if ftype == TType.I64:
7051 
          self.providerId = iprot.readI64();
7052 
        else:
7053 
          iprot.skip(ftype)
7054 
      elif fid == 2:
7055 
        if ftype == TType.MAP:
7056 
          self.undeliveredOrders = {}
3014 chandransh 7057 
          (_ktype126, _vtype127, _size125 ) = iprot.readMapBegin()
7058 
          for _i129 in xrange(_size125):
7059 
            _key130 = iprot.readString();
7060 
            _val131 = iprot.readString();
7061 
            self.undeliveredOrders[_key130] = _val131
1246 chandransh 7062 
          iprot.readMapEnd()
7063 
        else:
7064 
          iprot.skip(ftype)
7065 
      else:
7066 
        iprot.skip(ftype)
7067 
      iprot.readFieldEnd()
7068 
    iprot.readStructEnd()
7069 
 
7070 
  def write(self, oprot):
7071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7073 
      return
7074 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
7075 
    if self.providerId != None:
7076 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
7077 
      oprot.writeI64(self.providerId)
7078 
      oprot.writeFieldEnd()
7079 
    if self.undeliveredOrders != None:
7080 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
7081 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
3014 chandransh 7082 
      for kiter132,viter133 in self.undeliveredOrders.items():
7083 
        oprot.writeString(kiter132)
7084 
        oprot.writeString(viter133)
1246 chandransh 7085 
      oprot.writeMapEnd()
7086 
      oprot.writeFieldEnd()
7087 
    oprot.writeFieldStop()
7088 
    oprot.writeStructEnd()
7089 
 
7090 
  def __repr__(self):
7091 
    L = ['%s=%r' % (key, value)
7092 
      for key, value in self.__dict__.iteritems()]
7093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7094 
 
7095 
  def __eq__(self, other):
7096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7097 
 
7098 
  def __ne__(self, other):
7099 
    return not (self == other)
7100 
 
7101 
class updateNonDeliveryReason_result:
7102 
  """
7103 
  Attributes:
7104 
   - ex
7105 
  """
7106 
 
7107 
  thrift_spec = (
7108 
    None, # 0
7109 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7110 
  )
7111 
 
7112 
  def __init__(self, ex=None,):
7113 
    self.ex = ex
7114 
 
7115 
  def read(self, iprot):
7116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7118 
      return
7119 
    iprot.readStructBegin()
7120 
    while True:
7121 
      (fname, ftype, fid) = iprot.readFieldBegin()
7122 
      if ftype == TType.STOP:
7123 
        break
7124 
      if fid == 1:
7125 
        if ftype == TType.STRUCT:
7126 
          self.ex = TransactionServiceException()
7127 
          self.ex.read(iprot)
7128 
        else:
7129 
          iprot.skip(ftype)
7130 
      else:
7131 
        iprot.skip(ftype)
7132 
      iprot.readFieldEnd()
7133 
    iprot.readStructEnd()
7134 
 
7135 
  def write(self, oprot):
7136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7138 
      return
7139 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
7140 
    if self.ex != None:
7141 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7142 
      self.ex.write(oprot)
7143 
      oprot.writeFieldEnd()
7144 
    oprot.writeFieldStop()
7145 
    oprot.writeStructEnd()
7146 
 
7147 
  def __repr__(self):
7148 
    L = ['%s=%r' % (key, value)
7149 
      for key, value in self.__dict__.iteritems()]
7150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7151 
 
7152 
  def __eq__(self, other):
7153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7154 
 
7155 
  def __ne__(self, other):
7156 
    return not (self == other)
7157 
 
1408 ankur.sing 7158 
class getUndeliveredOrders_args:
7159 
  """
7160 
  Attributes:
7161 
   - providerId
7162 
   - warehouseId
7163 
  """
7164 
 
7165 
  thrift_spec = (
7166 
    None, # 0
7167 
    (1, TType.I64, 'providerId', None, None, ), # 1
7168 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7169 
  )
7170 
 
7171 
  def __init__(self, providerId=None, warehouseId=None,):
7172 
    self.providerId = providerId
7173 
    self.warehouseId = warehouseId
7174 
 
7175 
  def read(self, iprot):
7176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7178 
      return
7179 
    iprot.readStructBegin()
7180 
    while True:
7181 
      (fname, ftype, fid) = iprot.readFieldBegin()
7182 
      if ftype == TType.STOP:
7183 
        break
7184 
      if fid == 1:
7185 
        if ftype == TType.I64:
7186 
          self.providerId = iprot.readI64();
7187 
        else:
7188 
          iprot.skip(ftype)
7189 
      elif fid == 2:
7190 
        if ftype == TType.I64:
7191 
          self.warehouseId = iprot.readI64();
7192 
        else:
7193 
          iprot.skip(ftype)
7194 
      else:
7195 
        iprot.skip(ftype)
7196 
      iprot.readFieldEnd()
7197 
    iprot.readStructEnd()
7198 
 
7199 
  def write(self, oprot):
7200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7202 
      return
7203 
    oprot.writeStructBegin('getUndeliveredOrders_args')
7204 
    if self.providerId != None:
7205 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
7206 
      oprot.writeI64(self.providerId)
7207 
      oprot.writeFieldEnd()
7208 
    if self.warehouseId != None:
7209 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7210 
      oprot.writeI64(self.warehouseId)
7211 
      oprot.writeFieldEnd()
7212 
    oprot.writeFieldStop()
7213 
    oprot.writeStructEnd()
7214 
 
7215 
  def __repr__(self):
7216 
    L = ['%s=%r' % (key, value)
7217 
      for key, value in self.__dict__.iteritems()]
7218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7219 
 
7220 
  def __eq__(self, other):
7221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7222 
 
7223 
  def __ne__(self, other):
7224 
    return not (self == other)
7225 
 
7226 
class getUndeliveredOrders_result:
7227 
  """
7228 
  Attributes:
7229 
   - success
7230 
  """
7231 
 
7232 
  thrift_spec = (
7233 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7234 
  )
7235 
 
7236 
  def __init__(self, success=None,):
7237 
    self.success = success
7238 
 
7239 
  def read(self, iprot):
7240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7242 
      return
7243 
    iprot.readStructBegin()
7244 
    while True:
7245 
      (fname, ftype, fid) = iprot.readFieldBegin()
7246 
      if ftype == TType.STOP:
7247 
        break
7248 
      if fid == 0:
7249 
        if ftype == TType.LIST:
7250 
          self.success = []
3014 chandransh 7251 
          (_etype137, _size134) = iprot.readListBegin()
7252 
          for _i138 in xrange(_size134):
7253 
            _elem139 = Order()
7254 
            _elem139.read(iprot)
7255 
            self.success.append(_elem139)
1408 ankur.sing 7256 
          iprot.readListEnd()
7257 
        else:
7258 
          iprot.skip(ftype)
7259 
      else:
7260 
        iprot.skip(ftype)
7261 
      iprot.readFieldEnd()
7262 
    iprot.readStructEnd()
7263 
 
7264 
  def write(self, oprot):
7265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7267 
      return
7268 
    oprot.writeStructBegin('getUndeliveredOrders_result')
7269 
    if self.success != None:
7270 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7271 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3014 chandransh 7272 
      for iter140 in self.success:
7273 
        iter140.write(oprot)
1408 ankur.sing 7274 
      oprot.writeListEnd()
7275 
      oprot.writeFieldEnd()
7276 
    oprot.writeFieldStop()
7277 
    oprot.writeStructEnd()
7278 
 
7279 
  def __repr__(self):
7280 
    L = ['%s=%r' % (key, value)
7281 
      for key, value in self.__dict__.iteritems()]
7282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7283 
 
7284 
  def __eq__(self, other):
7285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7286 
 
7287 
  def __ne__(self, other):
7288 
    return not (self == other)
7289 
 
304 ashish 7290 
class getAlerts_args:
7291 
  """
7292 
  Attributes:
483 rajveer 7293 
   - orderId
304 ashish 7294 
   - valid
7295 
  """
94 ashish 7296 
 
304 ashish 7297 
  thrift_spec = (
7298 
    None, # 0
483 rajveer 7299 
    (1, TType.I64, 'orderId', None, None, ), # 1
304 ashish 7300 
    (2, TType.BOOL, 'valid', None, None, ), # 2
7301 
  )
7302 
 
483 rajveer 7303 
  def __init__(self, orderId=None, valid=None,):
7304 
    self.orderId = orderId
304 ashish 7305 
    self.valid = valid
7306 
 
7307 
  def read(self, iprot):
7308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7310 
      return
7311 
    iprot.readStructBegin()
7312 
    while True:
7313 
      (fname, ftype, fid) = iprot.readFieldBegin()
7314 
      if ftype == TType.STOP:
7315 
        break
7316 
      if fid == 1:
7317 
        if ftype == TType.I64:
483 rajveer 7318 
          self.orderId = iprot.readI64();
304 ashish 7319 
        else:
7320 
          iprot.skip(ftype)
7321 
      elif fid == 2:
7322 
        if ftype == TType.BOOL:
7323 
          self.valid = iprot.readBool();
7324 
        else:
7325 
          iprot.skip(ftype)
7326 
      else:
7327 
        iprot.skip(ftype)
7328 
      iprot.readFieldEnd()
7329 
    iprot.readStructEnd()
7330 
 
7331 
  def write(self, oprot):
7332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7334 
      return
7335 
    oprot.writeStructBegin('getAlerts_args')
483 rajveer 7336 
    if self.orderId != None:
7337 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7338 
      oprot.writeI64(self.orderId)
304 ashish 7339 
      oprot.writeFieldEnd()
7340 
    if self.valid != None:
7341 
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
7342 
      oprot.writeBool(self.valid)
7343 
      oprot.writeFieldEnd()
7344 
    oprot.writeFieldStop()
7345 
    oprot.writeStructEnd()
7346 
 
7347 
  def __repr__(self):
7348 
    L = ['%s=%r' % (key, value)
7349 
      for key, value in self.__dict__.iteritems()]
7350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7351 
 
7352 
  def __eq__(self, other):
7353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7354 
 
7355 
  def __ne__(self, other):
7356 
    return not (self == other)
7357 
 
7358 
class getAlerts_result:
7359 
  """
7360 
  Attributes:
7361 
   - success
7362 
  """
7363 
 
7364 
  thrift_spec = (
7365 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
7366 
  )
7367 
 
7368 
  def __init__(self, success=None,):
7369 
    self.success = success
7370 
 
7371 
  def read(self, iprot):
7372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7374 
      return
7375 
    iprot.readStructBegin()
7376 
    while True:
7377 
      (fname, ftype, fid) = iprot.readFieldBegin()
7378 
      if ftype == TType.STOP:
7379 
        break
7380 
      if fid == 0:
7381 
        if ftype == TType.LIST:
7382 
          self.success = []
3014 chandransh 7383 
          (_etype144, _size141) = iprot.readListBegin()
7384 
          for _i145 in xrange(_size141):
7385 
            _elem146 = Alert()
7386 
            _elem146.read(iprot)
7387 
            self.success.append(_elem146)
304 ashish 7388 
          iprot.readListEnd()
7389 
        else:
7390 
          iprot.skip(ftype)
7391 
      else:
7392 
        iprot.skip(ftype)
7393 
      iprot.readFieldEnd()
7394 
    iprot.readStructEnd()
7395 
 
7396 
  def write(self, oprot):
7397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7399 
      return
7400 
    oprot.writeStructBegin('getAlerts_result')
7401 
    if self.success != None:
7402 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7403 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3014 chandransh 7404 
      for iter147 in self.success:
7405 
        iter147.write(oprot)
304 ashish 7406 
      oprot.writeListEnd()
7407 
      oprot.writeFieldEnd()
7408 
    oprot.writeFieldStop()
7409 
    oprot.writeStructEnd()
7410 
 
7411 
  def __repr__(self):
7412 
    L = ['%s=%r' % (key, value)
7413 
      for key, value in self.__dict__.iteritems()]
7414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7415 
 
7416 
  def __eq__(self, other):
7417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7418 
 
7419 
  def __ne__(self, other):
7420 
    return not (self == other)
7421 
 
7422 
class setAlert_args:
7423 
  """
7424 
  Attributes:
483 rajveer 7425 
   - orderId
304 ashish 7426 
   - unset
7427 
   - type
7428 
   - comment
7429 
  """
7430 
 
7431 
  thrift_spec = (
7432 
    None, # 0
483 rajveer 7433 
    (1, TType.I64, 'orderId', None, None, ), # 1
304 ashish 7434 
    (2, TType.BOOL, 'unset', None, None, ), # 2
7435 
    (3, TType.I64, 'type', None, None, ), # 3
7436 
    (4, TType.STRING, 'comment', None, None, ), # 4
7437 
  )
7438 
 
483 rajveer 7439 
  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
7440 
    self.orderId = orderId
304 ashish 7441 
    self.unset = unset
7442 
    self.type = type
7443 
    self.comment = comment
7444 
 
7445 
  def read(self, iprot):
7446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7448 
      return
7449 
    iprot.readStructBegin()
7450 
    while True:
7451 
      (fname, ftype, fid) = iprot.readFieldBegin()
7452 
      if ftype == TType.STOP:
7453 
        break
7454 
      if fid == 1:
7455 
        if ftype == TType.I64:
483 rajveer 7456 
          self.orderId = iprot.readI64();
304 ashish 7457 
        else:
7458 
          iprot.skip(ftype)
7459 
      elif fid == 2:
7460 
        if ftype == TType.BOOL:
7461 
          self.unset = iprot.readBool();
7462 
        else:
7463 
          iprot.skip(ftype)
7464 
      elif fid == 3:
7465 
        if ftype == TType.I64:
7466 
          self.type = iprot.readI64();
7467 
        else:
7468 
          iprot.skip(ftype)
7469 
      elif fid == 4:
7470 
        if ftype == TType.STRING:
7471 
          self.comment = iprot.readString();
7472 
        else:
7473 
          iprot.skip(ftype)
7474 
      else:
7475 
        iprot.skip(ftype)
7476 
      iprot.readFieldEnd()
7477 
    iprot.readStructEnd()
7478 
 
7479 
  def write(self, oprot):
7480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7482 
      return
7483 
    oprot.writeStructBegin('setAlert_args')
483 rajveer 7484 
    if self.orderId != None:
7485 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7486 
      oprot.writeI64(self.orderId)
304 ashish 7487 
      oprot.writeFieldEnd()
7488 
    if self.unset != None:
7489 
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
7490 
      oprot.writeBool(self.unset)
7491 
      oprot.writeFieldEnd()
7492 
    if self.type != None:
7493 
      oprot.writeFieldBegin('type', TType.I64, 3)
7494 
      oprot.writeI64(self.type)
7495 
      oprot.writeFieldEnd()
7496 
    if self.comment != None:
7497 
      oprot.writeFieldBegin('comment', TType.STRING, 4)
7498 
      oprot.writeString(self.comment)
7499 
      oprot.writeFieldEnd()
7500 
    oprot.writeFieldStop()
7501 
    oprot.writeStructEnd()
7502 
 
7503 
  def __repr__(self):
7504 
    L = ['%s=%r' % (key, value)
7505 
      for key, value in self.__dict__.iteritems()]
7506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7507 
 
7508 
  def __eq__(self, other):
7509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7510 
 
7511 
  def __ne__(self, other):
7512 
    return not (self == other)
7513 
 
7514 
class setAlert_result:
7515 
 
7516 
  thrift_spec = (
7517 
  )
7518 
 
7519 
  def read(self, iprot):
7520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7522 
      return
7523 
    iprot.readStructBegin()
7524 
    while True:
7525 
      (fname, ftype, fid) = iprot.readFieldBegin()
7526 
      if ftype == TType.STOP:
7527 
        break
7528 
      else:
7529 
        iprot.skip(ftype)
7530 
      iprot.readFieldEnd()
7531 
    iprot.readStructEnd()
7532 
 
7533 
  def write(self, oprot):
7534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7536 
      return
7537 
    oprot.writeStructBegin('setAlert_result')
7538 
    oprot.writeFieldStop()
7539 
    oprot.writeStructEnd()
7540 
 
7541 
  def __repr__(self):
7542 
    L = ['%s=%r' % (key, value)
7543 
      for key, value in self.__dict__.iteritems()]
7544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7545 
 
7546 
  def __eq__(self, other):
7547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7548 
 
7549 
  def __ne__(self, other):
7550 
    return not (self == other)
7551 
 
1596 ankur.sing 7552 
class getValidOrderCount_args:
304 ashish 7553 
 
1596 ankur.sing 7554 
  thrift_spec = (
7555 
  )
7556 
 
7557 
  def read(self, iprot):
7558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7560 
      return
7561 
    iprot.readStructBegin()
7562 
    while True:
7563 
      (fname, ftype, fid) = iprot.readFieldBegin()
7564 
      if ftype == TType.STOP:
7565 
        break
7566 
      else:
7567 
        iprot.skip(ftype)
7568 
      iprot.readFieldEnd()
7569 
    iprot.readStructEnd()
7570 
 
7571 
  def write(self, oprot):
7572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7574 
      return
7575 
    oprot.writeStructBegin('getValidOrderCount_args')
7576 
    oprot.writeFieldStop()
7577 
    oprot.writeStructEnd()
7578 
 
7579 
  def __repr__(self):
7580 
    L = ['%s=%r' % (key, value)
7581 
      for key, value in self.__dict__.iteritems()]
7582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7583 
 
7584 
  def __eq__(self, other):
7585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7586 
 
7587 
  def __ne__(self, other):
7588 
    return not (self == other)
7589 
 
7590 
class getValidOrderCount_result:
7591 
  """
7592 
  Attributes:
7593 
   - success
7594 
  """
7595 
 
7596 
  thrift_spec = (
7597 
    (0, TType.I64, 'success', None, None, ), # 0
7598 
  )
7599 
 
7600 
  def __init__(self, success=None,):
7601 
    self.success = success
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.I64:
7614 
          self.success = iprot.readI64();
7615 
        else:
7616 
          iprot.skip(ftype)
7617 
      else:
7618 
        iprot.skip(ftype)
7619 
      iprot.readFieldEnd()
7620 
    iprot.readStructEnd()
7621 
 
7622 
  def write(self, oprot):
7623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7625 
      return
7626 
    oprot.writeStructBegin('getValidOrderCount_result')
7627 
    if self.success != None:
7628 
      oprot.writeFieldBegin('success', TType.I64, 0)
7629 
      oprot.writeI64(self.success)
7630 
      oprot.writeFieldEnd()
7631 
    oprot.writeFieldStop()
7632 
    oprot.writeStructEnd()
7633 
 
7634 
  def __repr__(self):
7635 
    L = ['%s=%r' % (key, value)
7636 
      for key, value in self.__dict__.iteritems()]
7637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7638 
 
7639 
  def __eq__(self, other):
7640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7641 
 
7642 
  def __ne__(self, other):
7643 
    return not (self == other)
7644 
 
1627 ankur.sing 7645 
class getNoOfCustomersWithSuccessfulTransaction_args:
1596 ankur.sing 7646 
 
1627 ankur.sing 7647 
  thrift_spec = (
7648 
  )
7649 
 
7650 
  def read(self, iprot):
7651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7653 
      return
7654 
    iprot.readStructBegin()
7655 
    while True:
7656 
      (fname, ftype, fid) = iprot.readFieldBegin()
7657 
      if ftype == TType.STOP:
7658 
        break
7659 
      else:
7660 
        iprot.skip(ftype)
7661 
      iprot.readFieldEnd()
7662 
    iprot.readStructEnd()
7663 
 
7664 
  def write(self, oprot):
7665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7667 
      return
7668 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
7669 
    oprot.writeFieldStop()
7670 
    oprot.writeStructEnd()
7671 
 
7672 
  def __repr__(self):
7673 
    L = ['%s=%r' % (key, value)
7674 
      for key, value in self.__dict__.iteritems()]
7675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7676 
 
7677 
  def __eq__(self, other):
7678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7679 
 
7680 
  def __ne__(self, other):
7681 
    return not (self == other)
7682 
 
7683 
class getNoOfCustomersWithSuccessfulTransaction_result:
7684 
  """
7685 
  Attributes:
7686 
   - success
7687 
  """
7688 
 
7689 
  thrift_spec = (
7690 
    (0, TType.I64, 'success', None, None, ), # 0
7691 
  )
7692 
 
7693 
  def __init__(self, success=None,):
7694 
    self.success = success
7695 
 
7696 
  def read(self, iprot):
7697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7699 
      return
7700 
    iprot.readStructBegin()
7701 
    while True:
7702 
      (fname, ftype, fid) = iprot.readFieldBegin()
7703 
      if ftype == TType.STOP:
7704 
        break
7705 
      if fid == 0:
7706 
        if ftype == TType.I64:
7707 
          self.success = iprot.readI64();
7708 
        else:
7709 
          iprot.skip(ftype)
7710 
      else:
7711 
        iprot.skip(ftype)
7712 
      iprot.readFieldEnd()
7713 
    iprot.readStructEnd()
7714 
 
7715 
  def write(self, oprot):
7716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7718 
      return
7719 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
7720 
    if self.success != None:
7721 
      oprot.writeFieldBegin('success', TType.I64, 0)
7722 
      oprot.writeI64(self.success)
7723 
      oprot.writeFieldEnd()
7724 
    oprot.writeFieldStop()
7725 
    oprot.writeStructEnd()
7726 
 
7727 
  def __repr__(self):
7728 
    L = ['%s=%r' % (key, value)
7729 
      for key, value in self.__dict__.iteritems()]
7730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7731 
 
7732 
  def __eq__(self, other):
7733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7734 
 
7735 
  def __ne__(self, other):
7736 
    return not (self == other)
7737 
 
1731 ankur.sing 7738 
class getValidOrdersAmountRange_args:
1627 ankur.sing 7739 
 
7740 
  thrift_spec = (
7741 
  )
7742 
 
7743 
  def read(self, iprot):
7744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7746 
      return
7747 
    iprot.readStructBegin()
7748 
    while True:
7749 
      (fname, ftype, fid) = iprot.readFieldBegin()
7750 
      if ftype == TType.STOP:
7751 
        break
7752 
      else:
7753 
        iprot.skip(ftype)
7754 
      iprot.readFieldEnd()
7755 
    iprot.readStructEnd()
7756 
 
7757 
  def write(self, oprot):
7758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7760 
      return
1731 ankur.sing 7761 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
1627 ankur.sing 7762 
    oprot.writeFieldStop()
7763 
    oprot.writeStructEnd()
7764 
 
7765 
  def __repr__(self):
7766 
    L = ['%s=%r' % (key, value)
7767 
      for key, value in self.__dict__.iteritems()]
7768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7769 
 
7770 
  def __eq__(self, other):
7771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7772 
 
7773 
  def __ne__(self, other):
7774 
    return not (self == other)
7775 
 
1731 ankur.sing 7776 
class getValidOrdersAmountRange_result:
1627 ankur.sing 7777 
  """
7778 
  Attributes:
7779 
   - success
7780 
  """
7781 
 
7782 
  thrift_spec = (
1731 ankur.sing 7783 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
1627 ankur.sing 7784 
  )
7785 
 
7786 
  def __init__(self, success=None,):
7787 
    self.success = success
7788 
 
7789 
  def read(self, iprot):
7790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7792 
      return
7793 
    iprot.readStructBegin()
7794 
    while True:
7795 
      (fname, ftype, fid) = iprot.readFieldBegin()
7796 
      if ftype == TType.STOP:
7797 
        break
7798 
      if fid == 0:
1731 ankur.sing 7799 
        if ftype == TType.LIST:
7800 
          self.success = []
3014 chandransh 7801 
          (_etype151, _size148) = iprot.readListBegin()
7802 
          for _i152 in xrange(_size148):
7803 
            _elem153 = iprot.readDouble();
7804 
            self.success.append(_elem153)
1731 ankur.sing 7805 
          iprot.readListEnd()
1627 ankur.sing 7806 
        else:
7807 
          iprot.skip(ftype)
7808 
      else:
7809 
        iprot.skip(ftype)
7810 
      iprot.readFieldEnd()
7811 
    iprot.readStructEnd()
7812 
 
7813 
  def write(self, oprot):
7814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7816 
      return
1731 ankur.sing 7817 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
1627 ankur.sing 7818 
    if self.success != None:
1731 ankur.sing 7819 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7820 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
3014 chandransh 7821 
      for iter154 in self.success:
7822 
        oprot.writeDouble(iter154)
1731 ankur.sing 7823 
      oprot.writeListEnd()
1627 ankur.sing 7824 
      oprot.writeFieldEnd()
7825 
    oprot.writeFieldStop()
7826 
    oprot.writeStructEnd()
7827 
 
7828 
  def __repr__(self):
7829 
    L = ['%s=%r' % (key, value)
7830 
      for key, value in self.__dict__.iteritems()]
7831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7832 
 
7833 
  def __eq__(self, other):
7834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7835 
 
7836 
  def __ne__(self, other):
7837 
    return not (self == other)
7838 
 
1886 ankur.sing 7839 
class getValidOrders_args:
7840 
  """
7841 
  Attributes:
7842 
   - limit
7843 
  """
1627 ankur.sing 7844 
 
1886 ankur.sing 7845 
  thrift_spec = (
7846 
    None, # 0
7847 
    (1, TType.I64, 'limit', None, None, ), # 1
7848 
  )
7849 
 
7850 
  def __init__(self, limit=None,):
7851 
    self.limit = limit
7852 
 
7853 
  def read(self, iprot):
7854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7856 
      return
7857 
    iprot.readStructBegin()
7858 
    while True:
7859 
      (fname, ftype, fid) = iprot.readFieldBegin()
7860 
      if ftype == TType.STOP:
7861 
        break
7862 
      if fid == 1:
7863 
        if ftype == TType.I64:
7864 
          self.limit = iprot.readI64();
7865 
        else:
7866 
          iprot.skip(ftype)
7867 
      else:
7868 
        iprot.skip(ftype)
7869 
      iprot.readFieldEnd()
7870 
    iprot.readStructEnd()
7871 
 
7872 
  def write(self, oprot):
7873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7875 
      return
7876 
    oprot.writeStructBegin('getValidOrders_args')
7877 
    if self.limit != None:
7878 
      oprot.writeFieldBegin('limit', TType.I64, 1)
7879 
      oprot.writeI64(self.limit)
7880 
      oprot.writeFieldEnd()
7881 
    oprot.writeFieldStop()
7882 
    oprot.writeStructEnd()
7883 
 
7884 
  def __repr__(self):
7885 
    L = ['%s=%r' % (key, value)
7886 
      for key, value in self.__dict__.iteritems()]
7887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7888 
 
7889 
  def __eq__(self, other):
7890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7891 
 
7892 
  def __ne__(self, other):
7893 
    return not (self == other)
7894 
 
7895 
class getValidOrders_result:
7896 
  """
7897 
  Attributes:
7898 
   - success
7899 
  """
7900 
 
7901 
  thrift_spec = (
7902 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7903 
  )
7904 
 
7905 
  def __init__(self, success=None,):
7906 
    self.success = success
7907 
 
7908 
  def read(self, iprot):
7909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7911 
      return
7912 
    iprot.readStructBegin()
7913 
    while True:
7914 
      (fname, ftype, fid) = iprot.readFieldBegin()
7915 
      if ftype == TType.STOP:
7916 
        break
7917 
      if fid == 0:
7918 
        if ftype == TType.LIST:
7919 
          self.success = []
3014 chandransh 7920 
          (_etype158, _size155) = iprot.readListBegin()
7921 
          for _i159 in xrange(_size155):
7922 
            _elem160 = Order()
7923 
            _elem160.read(iprot)
7924 
            self.success.append(_elem160)
1886 ankur.sing 7925 
          iprot.readListEnd()
7926 
        else:
7927 
          iprot.skip(ftype)
7928 
      else:
7929 
        iprot.skip(ftype)
7930 
      iprot.readFieldEnd()
7931 
    iprot.readStructEnd()
7932 
 
7933 
  def write(self, oprot):
7934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7936 
      return
7937 
    oprot.writeStructBegin('getValidOrders_result')
7938 
    if self.success != None:
7939 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7940 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3014 chandransh 7941 
      for iter161 in self.success:
7942 
        iter161.write(oprot)
1886 ankur.sing 7943 
      oprot.writeListEnd()
7944 
      oprot.writeFieldEnd()
7945 
    oprot.writeFieldStop()
7946 
    oprot.writeStructEnd()
7947 
 
7948 
  def __repr__(self):
7949 
    L = ['%s=%r' % (key, value)
7950 
      for key, value in self.__dict__.iteritems()]
7951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7952 
 
7953 
  def __eq__(self, other):
7954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7955 
 
7956 
  def __ne__(self, other):
7957 
    return not (self == other)
7958 
 
2536 chandransh 7959 
class toggleDOAFlag_args:
7960 
  """
7961 
  Attributes:
7962 
   - orderId
7963 
  """
1886 ankur.sing 7964 
 
2536 chandransh 7965 
  thrift_spec = (
7966 
    None, # 0
7967 
    (1, TType.I64, 'orderId', None, None, ), # 1
7968 
  )
7969 
 
7970 
  def __init__(self, orderId=None,):
7971 
    self.orderId = orderId
7972 
 
7973 
  def read(self, iprot):
7974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7976 
      return
7977 
    iprot.readStructBegin()
7978 
    while True:
7979 
      (fname, ftype, fid) = iprot.readFieldBegin()
7980 
      if ftype == TType.STOP:
7981 
        break
7982 
      if fid == 1:
7983 
        if ftype == TType.I64:
7984 
          self.orderId = iprot.readI64();
7985 
        else:
7986 
          iprot.skip(ftype)
7987 
      else:
7988 
        iprot.skip(ftype)
7989 
      iprot.readFieldEnd()
7990 
    iprot.readStructEnd()
7991 
 
7992 
  def write(self, oprot):
7993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7995 
      return
7996 
    oprot.writeStructBegin('toggleDOAFlag_args')
7997 
    if self.orderId != None:
7998 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7999 
      oprot.writeI64(self.orderId)
8000 
      oprot.writeFieldEnd()
8001 
    oprot.writeFieldStop()
8002 
    oprot.writeStructEnd()
8003 
 
8004 
  def __repr__(self):
8005 
    L = ['%s=%r' % (key, value)
8006 
      for key, value in self.__dict__.iteritems()]
8007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8008 
 
8009 
  def __eq__(self, other):
8010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8011 
 
8012 
  def __ne__(self, other):
8013 
    return not (self == other)
8014 
 
8015 
class toggleDOAFlag_result:
8016 
  """
8017 
  Attributes:
8018 
   - success
8019 
   - ex
8020 
  """
8021 
 
8022 
  thrift_spec = (
8023 
    (0, TType.BOOL, 'success', None, None, ), # 0
8024 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8025 
  )
8026 
 
8027 
  def __init__(self, success=None, ex=None,):
8028 
    self.success = success
8029 
    self.ex = ex
8030 
 
8031 
  def read(self, iprot):
8032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8034 
      return
8035 
    iprot.readStructBegin()
8036 
    while True:
8037 
      (fname, ftype, fid) = iprot.readFieldBegin()
8038 
      if ftype == TType.STOP:
8039 
        break
8040 
      if fid == 0:
8041 
        if ftype == TType.BOOL:
8042 
          self.success = iprot.readBool();
8043 
        else:
8044 
          iprot.skip(ftype)
8045 
      elif fid == 1:
8046 
        if ftype == TType.STRUCT:
8047 
          self.ex = TransactionServiceException()
8048 
          self.ex.read(iprot)
8049 
        else:
8050 
          iprot.skip(ftype)
8051 
      else:
8052 
        iprot.skip(ftype)
8053 
      iprot.readFieldEnd()
8054 
    iprot.readStructEnd()
8055 
 
8056 
  def write(self, oprot):
8057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8059 
      return
8060 
    oprot.writeStructBegin('toggleDOAFlag_result')
8061 
    if self.success != None:
8062 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8063 
      oprot.writeBool(self.success)
8064 
      oprot.writeFieldEnd()
8065 
    if self.ex != None:
8066 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8067 
      self.ex.write(oprot)
8068 
      oprot.writeFieldEnd()
8069 
    oprot.writeFieldStop()
8070 
    oprot.writeStructEnd()
8071 
 
8072 
  def __repr__(self):
8073 
    L = ['%s=%r' % (key, value)
8074 
      for key, value in self.__dict__.iteritems()]
8075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8076 
 
8077 
  def __eq__(self, other):
8078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8079 
 
8080 
  def __ne__(self, other):
8081 
    return not (self == other)
8082 
 
8083 
class requestPickupNumber_args:
8084 
  """
8085 
  Attributes:
8086 
   - orderId
8087 
  """
8088 
 
8089 
  thrift_spec = (
8090 
    None, # 0
8091 
    (1, TType.I64, 'orderId', None, None, ), # 1
8092 
  )
8093 
 
8094 
  def __init__(self, orderId=None,):
8095 
    self.orderId = orderId
8096 
 
8097 
  def read(self, iprot):
8098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8100 
      return
8101 
    iprot.readStructBegin()
8102 
    while True:
8103 
      (fname, ftype, fid) = iprot.readFieldBegin()
8104 
      if ftype == TType.STOP:
8105 
        break
8106 
      if fid == 1:
8107 
        if ftype == TType.I64:
8108 
          self.orderId = iprot.readI64();
8109 
        else:
8110 
          iprot.skip(ftype)
8111 
      else:
8112 
        iprot.skip(ftype)
8113 
      iprot.readFieldEnd()
8114 
    iprot.readStructEnd()
8115 
 
8116 
  def write(self, oprot):
8117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8119 
      return
8120 
    oprot.writeStructBegin('requestPickupNumber_args')
8121 
    if self.orderId != None:
8122 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8123 
      oprot.writeI64(self.orderId)
8124 
      oprot.writeFieldEnd()
8125 
    oprot.writeFieldStop()
8126 
    oprot.writeStructEnd()
8127 
 
8128 
  def __repr__(self):
8129 
    L = ['%s=%r' % (key, value)
8130 
      for key, value in self.__dict__.iteritems()]
8131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8132 
 
8133 
  def __eq__(self, other):
8134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8135 
 
8136 
  def __ne__(self, other):
8137 
    return not (self == other)
8138 
 
8139 
class requestPickupNumber_result:
8140 
  """
8141 
  Attributes:
8142 
   - success
8143 
   - ex
8144 
  """
8145 
 
8146 
  thrift_spec = (
8147 
    (0, TType.BOOL, 'success', None, None, ), # 0
8148 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8149 
  )
8150 
 
8151 
  def __init__(self, success=None, ex=None,):
8152 
    self.success = success
8153 
    self.ex = ex
8154 
 
8155 
  def read(self, iprot):
8156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8158 
      return
8159 
    iprot.readStructBegin()
8160 
    while True:
8161 
      (fname, ftype, fid) = iprot.readFieldBegin()
8162 
      if ftype == TType.STOP:
8163 
        break
8164 
      if fid == 0:
8165 
        if ftype == TType.BOOL:
8166 
          self.success = iprot.readBool();
8167 
        else:
8168 
          iprot.skip(ftype)
8169 
      elif fid == 1:
8170 
        if ftype == TType.STRUCT:
8171 
          self.ex = TransactionServiceException()
8172 
          self.ex.read(iprot)
8173 
        else:
8174 
          iprot.skip(ftype)
8175 
      else:
8176 
        iprot.skip(ftype)
8177 
      iprot.readFieldEnd()
8178 
    iprot.readStructEnd()
8179 
 
8180 
  def write(self, oprot):
8181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8183 
      return
8184 
    oprot.writeStructBegin('requestPickupNumber_result')
8185 
    if self.success != None:
8186 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8187 
      oprot.writeBool(self.success)
8188 
      oprot.writeFieldEnd()
8189 
    if self.ex != None:
8190 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8191 
      self.ex.write(oprot)
8192 
      oprot.writeFieldEnd()
8193 
    oprot.writeFieldStop()
8194 
    oprot.writeStructEnd()
8195 
 
8196 
  def __repr__(self):
8197 
    L = ['%s=%r' % (key, value)
8198 
      for key, value in self.__dict__.iteritems()]
8199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8200 
 
8201 
  def __eq__(self, other):
8202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8203 
 
8204 
  def __ne__(self, other):
8205 
    return not (self == other)
8206 
 
8207 
class authorizePickup_args:
8208 
  """
8209 
  Attributes:
8210 
   - orderId
8211 
   - pickupNumber
8212 
  """
8213 
 
8214 
  thrift_spec = (
8215 
    None, # 0
8216 
    (1, TType.I64, 'orderId', None, None, ), # 1
8217 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
8218 
  )
8219 
 
8220 
  def __init__(self, orderId=None, pickupNumber=None,):
8221 
    self.orderId = orderId
8222 
    self.pickupNumber = pickupNumber
8223 
 
8224 
  def read(self, iprot):
8225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8227 
      return
8228 
    iprot.readStructBegin()
8229 
    while True:
8230 
      (fname, ftype, fid) = iprot.readFieldBegin()
8231 
      if ftype == TType.STOP:
8232 
        break
8233 
      if fid == 1:
8234 
        if ftype == TType.I64:
8235 
          self.orderId = iprot.readI64();
8236 
        else:
8237 
          iprot.skip(ftype)
8238 
      elif fid == 2:
8239 
        if ftype == TType.STRING:
8240 
          self.pickupNumber = iprot.readString();
8241 
        else:
8242 
          iprot.skip(ftype)
8243 
      else:
8244 
        iprot.skip(ftype)
8245 
      iprot.readFieldEnd()
8246 
    iprot.readStructEnd()
8247 
 
8248 
  def write(self, oprot):
8249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8251 
      return
8252 
    oprot.writeStructBegin('authorizePickup_args')
8253 
    if self.orderId != None:
8254 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8255 
      oprot.writeI64(self.orderId)
8256 
      oprot.writeFieldEnd()
8257 
    if self.pickupNumber != None:
8258 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
8259 
      oprot.writeString(self.pickupNumber)
8260 
      oprot.writeFieldEnd()
8261 
    oprot.writeFieldStop()
8262 
    oprot.writeStructEnd()
8263 
 
8264 
  def __repr__(self):
8265 
    L = ['%s=%r' % (key, value)
8266 
      for key, value in self.__dict__.iteritems()]
8267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8268 
 
8269 
  def __eq__(self, other):
8270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8271 
 
8272 
  def __ne__(self, other):
8273 
    return not (self == other)
8274 
 
8275 
class authorizePickup_result:
8276 
  """
8277 
  Attributes:
8278 
   - success
8279 
   - ex
8280 
  """
8281 
 
8282 
  thrift_spec = (
8283 
    (0, TType.BOOL, 'success', None, None, ), # 0
8284 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8285 
  )
8286 
 
8287 
  def __init__(self, success=None, ex=None,):
8288 
    self.success = success
8289 
    self.ex = ex
8290 
 
8291 
  def read(self, iprot):
8292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8294 
      return
8295 
    iprot.readStructBegin()
8296 
    while True:
8297 
      (fname, ftype, fid) = iprot.readFieldBegin()
8298 
      if ftype == TType.STOP:
8299 
        break
8300 
      if fid == 0:
8301 
        if ftype == TType.BOOL:
8302 
          self.success = iprot.readBool();
8303 
        else:
8304 
          iprot.skip(ftype)
8305 
      elif fid == 1:
8306 
        if ftype == TType.STRUCT:
8307 
          self.ex = TransactionServiceException()
8308 
          self.ex.read(iprot)
8309 
        else:
8310 
          iprot.skip(ftype)
8311 
      else:
8312 
        iprot.skip(ftype)
8313 
      iprot.readFieldEnd()
8314 
    iprot.readStructEnd()
8315 
 
8316 
  def write(self, oprot):
8317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8319 
      return
8320 
    oprot.writeStructBegin('authorizePickup_result')
8321 
    if self.success != None:
8322 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8323 
      oprot.writeBool(self.success)
8324 
      oprot.writeFieldEnd()
8325 
    if self.ex != None:
8326 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8327 
      self.ex.write(oprot)
8328 
      oprot.writeFieldEnd()
8329 
    oprot.writeFieldStop()
8330 
    oprot.writeStructEnd()
8331 
 
8332 
  def __repr__(self):
8333 
    L = ['%s=%r' % (key, value)
8334 
      for key, value in self.__dict__.iteritems()]
8335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8336 
 
8337 
  def __eq__(self, other):
8338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8339 
 
8340 
  def __ne__(self, other):
8341 
    return not (self == other)
8342 
 
2764 chandransh 8343 
class markDoasAsPickedUp_args:
8344 
  """
8345 
  Attributes:
8346 
   - providerId
8347 
   - pickupDetails
8348 
  """
8349 
 
8350 
  thrift_spec = (
8351 
    None, # 0
8352 
    (1, TType.I64, 'providerId', None, None, ), # 1
8353 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
8354 
  )
8355 
 
8356 
  def __init__(self, providerId=None, pickupDetails=None,):
8357 
    self.providerId = providerId
8358 
    self.pickupDetails = pickupDetails
8359 
 
8360 
  def read(self, iprot):
8361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8363 
      return
8364 
    iprot.readStructBegin()
8365 
    while True:
8366 
      (fname, ftype, fid) = iprot.readFieldBegin()
8367 
      if ftype == TType.STOP:
8368 
        break
8369 
      if fid == 1:
8370 
        if ftype == TType.I64:
8371 
          self.providerId = iprot.readI64();
8372 
        else:
8373 
          iprot.skip(ftype)
8374 
      elif fid == 2:
8375 
        if ftype == TType.MAP:
8376 
          self.pickupDetails = {}
3014 chandransh 8377 
          (_ktype163, _vtype164, _size162 ) = iprot.readMapBegin()
8378 
          for _i166 in xrange(_size162):
8379 
            _key167 = iprot.readString();
8380 
            _val168 = iprot.readString();
8381 
            self.pickupDetails[_key167] = _val168
2764 chandransh 8382 
          iprot.readMapEnd()
8383 
        else:
8384 
          iprot.skip(ftype)
8385 
      else:
8386 
        iprot.skip(ftype)
8387 
      iprot.readFieldEnd()
8388 
    iprot.readStructEnd()
8389 
 
8390 
  def write(self, oprot):
8391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8393 
      return
8394 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
8395 
    if self.providerId != None:
8396 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
8397 
      oprot.writeI64(self.providerId)
8398 
      oprot.writeFieldEnd()
8399 
    if self.pickupDetails != None:
8400 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
8401 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
3014 chandransh 8402 
      for kiter169,viter170 in self.pickupDetails.items():
8403 
        oprot.writeString(kiter169)
8404 
        oprot.writeString(viter170)
2764 chandransh 8405 
      oprot.writeMapEnd()
8406 
      oprot.writeFieldEnd()
8407 
    oprot.writeFieldStop()
8408 
    oprot.writeStructEnd()
8409 
 
8410 
  def __repr__(self):
8411 
    L = ['%s=%r' % (key, value)
8412 
      for key, value in self.__dict__.iteritems()]
8413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8414 
 
8415 
  def __eq__(self, other):
8416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8417 
 
8418 
  def __ne__(self, other):
8419 
    return not (self == other)
8420 
 
8421 
class markDoasAsPickedUp_result:
8422 
  """
8423 
  Attributes:
8424 
   - success
8425 
  """
8426 
 
8427 
  thrift_spec = (
8428 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
8429 
  )
8430 
 
8431 
  def __init__(self, success=None,):
8432 
    self.success = success
8433 
 
8434 
  def read(self, iprot):
8435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8437 
      return
8438 
    iprot.readStructBegin()
8439 
    while True:
8440 
      (fname, ftype, fid) = iprot.readFieldBegin()
8441 
      if ftype == TType.STOP:
8442 
        break
8443 
      if fid == 0:
8444 
        if ftype == TType.LIST:
8445 
          self.success = []
3014 chandransh 8446 
          (_etype174, _size171) = iprot.readListBegin()
8447 
          for _i175 in xrange(_size171):
8448 
            _elem176 = Order()
8449 
            _elem176.read(iprot)
8450 
            self.success.append(_elem176)
2764 chandransh 8451 
          iprot.readListEnd()
8452 
        else:
8453 
          iprot.skip(ftype)
8454 
      else:
8455 
        iprot.skip(ftype)
8456 
      iprot.readFieldEnd()
8457 
    iprot.readStructEnd()
8458 
 
8459 
  def write(self, oprot):
8460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8462 
      return
8463 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
8464 
    if self.success != None:
8465 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8466 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3014 chandransh 8467 
      for iter177 in self.success:
8468 
        iter177.write(oprot)
2764 chandransh 8469 
      oprot.writeListEnd()
8470 
      oprot.writeFieldEnd()
8471 
    oprot.writeFieldStop()
8472 
    oprot.writeStructEnd()
8473 
 
8474 
  def __repr__(self):
8475 
    L = ['%s=%r' % (key, value)
8476 
      for key, value in self.__dict__.iteritems()]
8477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8478 
 
8479 
  def __eq__(self, other):
8480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8481 
 
8482 
  def __ne__(self, other):
8483 
    return not (self == other)
8484 
 
2616 chandransh 8485 
class receiveReturn_args:
2591 chandransh 8486 
  """
8487 
  Attributes:
8488 
   - orderId
8489 
  """
2536 chandransh 8490 
 
2591 chandransh 8491 
  thrift_spec = (
8492 
    None, # 0
8493 
    (1, TType.I64, 'orderId', None, None, ), # 1
8494 
  )
8495 
 
8496 
  def __init__(self, orderId=None,):
8497 
    self.orderId = orderId
8498 
 
8499 
  def read(self, iprot):
8500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8502 
      return
8503 
    iprot.readStructBegin()
8504 
    while True:
8505 
      (fname, ftype, fid) = iprot.readFieldBegin()
8506 
      if ftype == TType.STOP:
8507 
        break
8508 
      if fid == 1:
8509 
        if ftype == TType.I64:
8510 
          self.orderId = iprot.readI64();
8511 
        else:
8512 
          iprot.skip(ftype)
8513 
      else:
8514 
        iprot.skip(ftype)
8515 
      iprot.readFieldEnd()
8516 
    iprot.readStructEnd()
8517 
 
8518 
  def write(self, oprot):
8519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8521 
      return
2616 chandransh 8522 
    oprot.writeStructBegin('receiveReturn_args')
2591 chandransh 8523 
    if self.orderId != None:
8524 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8525 
      oprot.writeI64(self.orderId)
8526 
      oprot.writeFieldEnd()
8527 
    oprot.writeFieldStop()
8528 
    oprot.writeStructEnd()
8529 
 
8530 
  def __repr__(self):
8531 
    L = ['%s=%r' % (key, value)
8532 
      for key, value in self.__dict__.iteritems()]
8533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8534 
 
8535 
  def __eq__(self, other):
8536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8537 
 
8538 
  def __ne__(self, other):
8539 
    return not (self == other)
8540 
 
2616 chandransh 8541 
class receiveReturn_result:
2591 chandransh 8542 
  """
8543 
  Attributes:
8544 
   - success
8545 
   - ex
8546 
  """
8547 
 
8548 
  thrift_spec = (
8549 
    (0, TType.BOOL, 'success', None, None, ), # 0
8550 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8551 
  )
8552 
 
8553 
  def __init__(self, success=None, ex=None,):
8554 
    self.success = success
8555 
    self.ex = ex
8556 
 
8557 
  def read(self, iprot):
8558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8560 
      return
8561 
    iprot.readStructBegin()
8562 
    while True:
8563 
      (fname, ftype, fid) = iprot.readFieldBegin()
8564 
      if ftype == TType.STOP:
8565 
        break
8566 
      if fid == 0:
8567 
        if ftype == TType.BOOL:
8568 
          self.success = iprot.readBool();
8569 
        else:
8570 
          iprot.skip(ftype)
8571 
      elif fid == 1:
8572 
        if ftype == TType.STRUCT:
8573 
          self.ex = TransactionServiceException()
8574 
          self.ex.read(iprot)
8575 
        else:
8576 
          iprot.skip(ftype)
8577 
      else:
8578 
        iprot.skip(ftype)
8579 
      iprot.readFieldEnd()
8580 
    iprot.readStructEnd()
8581 
 
8582 
  def write(self, oprot):
8583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8585 
      return
2616 chandransh 8586 
    oprot.writeStructBegin('receiveReturn_result')
2591 chandransh 8587 
    if self.success != None:
8588 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8589 
      oprot.writeBool(self.success)
8590 
      oprot.writeFieldEnd()
8591 
    if self.ex != None:
8592 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8593 
      self.ex.write(oprot)
8594 
      oprot.writeFieldEnd()
8595 
    oprot.writeFieldStop()
8596 
    oprot.writeStructEnd()
8597 
 
8598 
  def __repr__(self):
8599 
    L = ['%s=%r' % (key, value)
8600 
      for key, value in self.__dict__.iteritems()]
8601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8602 
 
8603 
  def __eq__(self, other):
8604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8605 
 
8606 
  def __ne__(self, other):
8607 
    return not (self == other)
8608 
 
8609 
class validateDoa_args:
8610 
  """
8611 
  Attributes:
8612 
   - orderId
8613 
   - isValid
8614 
  """
8615 
 
8616 
  thrift_spec = (
8617 
    None, # 0
8618 
    (1, TType.I64, 'orderId', None, None, ), # 1
8619 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
8620 
  )
8621 
 
8622 
  def __init__(self, orderId=None, isValid=None,):
8623 
    self.orderId = orderId
8624 
    self.isValid = isValid
8625 
 
8626 
  def read(self, iprot):
8627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8629 
      return
8630 
    iprot.readStructBegin()
8631 
    while True:
8632 
      (fname, ftype, fid) = iprot.readFieldBegin()
8633 
      if ftype == TType.STOP:
8634 
        break
8635 
      if fid == 1:
8636 
        if ftype == TType.I64:
8637 
          self.orderId = iprot.readI64();
8638 
        else:
8639 
          iprot.skip(ftype)
8640 
      elif fid == 2:
8641 
        if ftype == TType.BOOL:
8642 
          self.isValid = iprot.readBool();
8643 
        else:
8644 
          iprot.skip(ftype)
8645 
      else:
8646 
        iprot.skip(ftype)
8647 
      iprot.readFieldEnd()
8648 
    iprot.readStructEnd()
8649 
 
8650 
  def write(self, oprot):
8651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8653 
      return
8654 
    oprot.writeStructBegin('validateDoa_args')
8655 
    if self.orderId != None:
8656 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8657 
      oprot.writeI64(self.orderId)
8658 
      oprot.writeFieldEnd()
8659 
    if self.isValid != None:
8660 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
8661 
      oprot.writeBool(self.isValid)
8662 
      oprot.writeFieldEnd()
8663 
    oprot.writeFieldStop()
8664 
    oprot.writeStructEnd()
8665 
 
8666 
  def __repr__(self):
8667 
    L = ['%s=%r' % (key, value)
8668 
      for key, value in self.__dict__.iteritems()]
8669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8670 
 
8671 
  def __eq__(self, other):
8672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8673 
 
8674 
  def __ne__(self, other):
8675 
    return not (self == other)
8676 
 
8677 
class validateDoa_result:
8678 
  """
8679 
  Attributes:
8680 
   - success
8681 
   - ex
8682 
  """
8683 
 
8684 
  thrift_spec = (
8685 
    (0, TType.BOOL, 'success', None, None, ), # 0
8686 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8687 
  )
8688 
 
8689 
  def __init__(self, success=None, ex=None,):
8690 
    self.success = success
8691 
    self.ex = ex
8692 
 
8693 
  def read(self, iprot):
8694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8696 
      return
8697 
    iprot.readStructBegin()
8698 
    while True:
8699 
      (fname, ftype, fid) = iprot.readFieldBegin()
8700 
      if ftype == TType.STOP:
8701 
        break
8702 
      if fid == 0:
8703 
        if ftype == TType.BOOL:
8704 
          self.success = iprot.readBool();
8705 
        else:
8706 
          iprot.skip(ftype)
8707 
      elif fid == 1:
8708 
        if ftype == TType.STRUCT:
8709 
          self.ex = TransactionServiceException()
8710 
          self.ex.read(iprot)
8711 
        else:
8712 
          iprot.skip(ftype)
8713 
      else:
8714 
        iprot.skip(ftype)
8715 
      iprot.readFieldEnd()
8716 
    iprot.readStructEnd()
8717 
 
8718 
  def write(self, oprot):
8719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8721 
      return
8722 
    oprot.writeStructBegin('validateDoa_result')
8723 
    if self.success != None:
8724 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8725 
      oprot.writeBool(self.success)
8726 
      oprot.writeFieldEnd()
8727 
    if self.ex != None:
8728 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8729 
      self.ex.write(oprot)
8730 
      oprot.writeFieldEnd()
8731 
    oprot.writeFieldStop()
8732 
    oprot.writeStructEnd()
8733 
 
8734 
  def __repr__(self):
8735 
    L = ['%s=%r' % (key, value)
8736 
      for key, value in self.__dict__.iteritems()]
8737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8738 
 
8739 
  def __eq__(self, other):
8740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8741 
 
8742 
  def __ne__(self, other):
8743 
    return not (self == other)
8744 
 
2616 chandransh 8745 
class reshipOrder_args:
8746 
  """
8747 
  Attributes:
8748 
   - orderId
8749 
  """
2591 chandransh 8750 
 
2616 chandransh 8751 
  thrift_spec = (
8752 
    None, # 0
8753 
    (1, TType.I64, 'orderId', None, None, ), # 1
8754 
  )
8755 
 
8756 
  def __init__(self, orderId=None,):
8757 
    self.orderId = orderId
8758 
 
8759 
  def read(self, iprot):
8760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8762 
      return
8763 
    iprot.readStructBegin()
8764 
    while True:
8765 
      (fname, ftype, fid) = iprot.readFieldBegin()
8766 
      if ftype == TType.STOP:
8767 
        break
8768 
      if fid == 1:
8769 
        if ftype == TType.I64:
8770 
          self.orderId = iprot.readI64();
8771 
        else:
8772 
          iprot.skip(ftype)
8773 
      else:
8774 
        iprot.skip(ftype)
8775 
      iprot.readFieldEnd()
8776 
    iprot.readStructEnd()
8777 
 
8778 
  def write(self, oprot):
8779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8781 
      return
8782 
    oprot.writeStructBegin('reshipOrder_args')
8783 
    if self.orderId != None:
8784 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8785 
      oprot.writeI64(self.orderId)
8786 
      oprot.writeFieldEnd()
8787 
    oprot.writeFieldStop()
8788 
    oprot.writeStructEnd()
8789 
 
8790 
  def __repr__(self):
8791 
    L = ['%s=%r' % (key, value)
8792 
      for key, value in self.__dict__.iteritems()]
8793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8794 
 
8795 
  def __eq__(self, other):
8796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8797 
 
8798 
  def __ne__(self, other):
8799 
    return not (self == other)
8800 
 
8801 
class reshipOrder_result:
8802 
  """
8803 
  Attributes:
8804 
   - success
8805 
   - ex
8806 
  """
8807 
 
8808 
  thrift_spec = (
8809 
    (0, TType.I64, 'success', None, None, ), # 0
8810 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8811 
  )
8812 
 
8813 
  def __init__(self, success=None, ex=None,):
8814 
    self.success = success
8815 
    self.ex = ex
8816 
 
8817 
  def read(self, iprot):
8818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8820 
      return
8821 
    iprot.readStructBegin()
8822 
    while True:
8823 
      (fname, ftype, fid) = iprot.readFieldBegin()
8824 
      if ftype == TType.STOP:
8825 
        break
8826 
      if fid == 0:
8827 
        if ftype == TType.I64:
8828 
          self.success = iprot.readI64();
8829 
        else:
8830 
          iprot.skip(ftype)
8831 
      elif fid == 1:
8832 
        if ftype == TType.STRUCT:
8833 
          self.ex = TransactionServiceException()
8834 
          self.ex.read(iprot)
8835 
        else:
8836 
          iprot.skip(ftype)
8837 
      else:
8838 
        iprot.skip(ftype)
8839 
      iprot.readFieldEnd()
8840 
    iprot.readStructEnd()
8841 
 
8842 
  def write(self, oprot):
8843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8845 
      return
8846 
    oprot.writeStructBegin('reshipOrder_result')
8847 
    if self.success != None:
8848 
      oprot.writeFieldBegin('success', TType.I64, 0)
8849 
      oprot.writeI64(self.success)
8850 
      oprot.writeFieldEnd()
8851 
    if self.ex != None:
8852 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8853 
      self.ex.write(oprot)
8854 
      oprot.writeFieldEnd()
8855 
    oprot.writeFieldStop()
8856 
    oprot.writeStructEnd()
8857 
 
8858 
  def __repr__(self):
8859 
    L = ['%s=%r' % (key, value)
8860 
      for key, value in self.__dict__.iteritems()]
8861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8862 
 
8863 
  def __eq__(self, other):
8864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8865 
 
8866 
  def __ne__(self, other):
8867 
    return not (self == other)
8868 
 
8869 
class refundOrder_args:
8870 
  """
8871 
  Attributes:
8872 
   - orderId
8873 
  """
8874 
 
8875 
  thrift_spec = (
8876 
    None, # 0
8877 
    (1, TType.I64, 'orderId', None, None, ), # 1
8878 
  )
8879 
 
8880 
  def __init__(self, orderId=None,):
8881 
    self.orderId = orderId
8882 
 
8883 
  def read(self, iprot):
8884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8886 
      return
8887 
    iprot.readStructBegin()
8888 
    while True:
8889 
      (fname, ftype, fid) = iprot.readFieldBegin()
8890 
      if ftype == TType.STOP:
8891 
        break
8892 
      if fid == 1:
8893 
        if ftype == TType.I64:
8894 
          self.orderId = iprot.readI64();
8895 
        else:
8896 
          iprot.skip(ftype)
8897 
      else:
8898 
        iprot.skip(ftype)
8899 
      iprot.readFieldEnd()
8900 
    iprot.readStructEnd()
8901 
 
8902 
  def write(self, oprot):
8903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8905 
      return
8906 
    oprot.writeStructBegin('refundOrder_args')
8907 
    if self.orderId != None:
8908 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8909 
      oprot.writeI64(self.orderId)
8910 
      oprot.writeFieldEnd()
8911 
    oprot.writeFieldStop()
8912 
    oprot.writeStructEnd()
8913 
 
8914 
  def __repr__(self):
8915 
    L = ['%s=%r' % (key, value)
8916 
      for key, value in self.__dict__.iteritems()]
8917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8918 
 
8919 
  def __eq__(self, other):
8920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8921 
 
8922 
  def __ne__(self, other):
8923 
    return not (self == other)
8924 
 
8925 
class refundOrder_result:
8926 
  """
8927 
  Attributes:
8928 
   - success
8929 
   - ex
8930 
  """
8931 
 
8932 
  thrift_spec = (
8933 
    (0, TType.BOOL, 'success', None, None, ), # 0
8934 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8935 
  )
8936 
 
8937 
  def __init__(self, success=None, ex=None,):
8938 
    self.success = success
8939 
    self.ex = ex
8940 
 
8941 
  def read(self, iprot):
8942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8944 
      return
8945 
    iprot.readStructBegin()
8946 
    while True:
8947 
      (fname, ftype, fid) = iprot.readFieldBegin()
8948 
      if ftype == TType.STOP:
8949 
        break
8950 
      if fid == 0:
8951 
        if ftype == TType.BOOL:
8952 
          self.success = iprot.readBool();
8953 
        else:
8954 
          iprot.skip(ftype)
8955 
      elif fid == 1:
8956 
        if ftype == TType.STRUCT:
8957 
          self.ex = TransactionServiceException()
8958 
          self.ex.read(iprot)
8959 
        else:
8960 
          iprot.skip(ftype)
8961 
      else:
8962 
        iprot.skip(ftype)
8963 
      iprot.readFieldEnd()
8964 
    iprot.readStructEnd()
8965 
 
8966 
  def write(self, oprot):
8967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8969 
      return
8970 
    oprot.writeStructBegin('refundOrder_result')
8971 
    if self.success != None:
8972 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8973 
      oprot.writeBool(self.success)
8974 
      oprot.writeFieldEnd()
8975 
    if self.ex != None:
8976 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8977 
      self.ex.write(oprot)
8978 
      oprot.writeFieldEnd()
8979 
    oprot.writeFieldStop()
8980 
    oprot.writeStructEnd()
8981 
 
8982 
  def __repr__(self):
8983 
    L = ['%s=%r' % (key, value)
8984 
      for key, value in self.__dict__.iteritems()]
8985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8986 
 
8987 
  def __eq__(self, other):
8988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8989 
 
8990 
  def __ne__(self, other):
8991 
    return not (self == other)
8992 
 
2690 chandransh 8993 
class getReturnOrders_args:
8994 
  """
8995 
  Attributes:
8996 
   - warehouseId
8997 
   - fromDate
8998 
   - toDate
8999 
  """
2616 chandransh 9000 
 
2690 chandransh 9001 
  thrift_spec = (
9002 
    None, # 0
9003 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9004 
    (2, TType.I64, 'fromDate', None, None, ), # 2
9005 
    (3, TType.I64, 'toDate', None, None, ), # 3
9006 
  )
9007 
 
9008 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
9009 
    self.warehouseId = warehouseId
9010 
    self.fromDate = fromDate
9011 
    self.toDate = toDate
9012 
 
9013 
  def read(self, iprot):
9014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9016 
      return
9017 
    iprot.readStructBegin()
9018 
    while True:
9019 
      (fname, ftype, fid) = iprot.readFieldBegin()
9020 
      if ftype == TType.STOP:
9021 
        break
9022 
      if fid == 1:
9023 
        if ftype == TType.I64:
9024 
          self.warehouseId = iprot.readI64();
9025 
        else:
9026 
          iprot.skip(ftype)
9027 
      elif fid == 2:
9028 
        if ftype == TType.I64:
9029 
          self.fromDate = iprot.readI64();
9030 
        else:
9031 
          iprot.skip(ftype)
9032 
      elif fid == 3:
9033 
        if ftype == TType.I64:
9034 
          self.toDate = iprot.readI64();
9035 
        else:
9036 
          iprot.skip(ftype)
9037 
      else:
9038 
        iprot.skip(ftype)
9039 
      iprot.readFieldEnd()
9040 
    iprot.readStructEnd()
9041 
 
9042 
  def write(self, oprot):
9043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9045 
      return
9046 
    oprot.writeStructBegin('getReturnOrders_args')
9047 
    if self.warehouseId != None:
9048 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9049 
      oprot.writeI64(self.warehouseId)
9050 
      oprot.writeFieldEnd()
9051 
    if self.fromDate != None:
9052 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
9053 
      oprot.writeI64(self.fromDate)
9054 
      oprot.writeFieldEnd()
9055 
    if self.toDate != None:
9056 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
9057 
      oprot.writeI64(self.toDate)
9058 
      oprot.writeFieldEnd()
9059 
    oprot.writeFieldStop()
9060 
    oprot.writeStructEnd()
9061 
 
9062 
  def __repr__(self):
9063 
    L = ['%s=%r' % (key, value)
9064 
      for key, value in self.__dict__.iteritems()]
9065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9066 
 
9067 
  def __eq__(self, other):
9068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9069 
 
9070 
  def __ne__(self, other):
9071 
    return not (self == other)
9072 
 
9073 
class getReturnOrders_result:
9074 
  """
9075 
  Attributes:
9076 
   - success
9077 
  """
9078 
 
9079 
  thrift_spec = (
9080 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
9081 
  )
9082 
 
9083 
  def __init__(self, success=None,):
9084 
    self.success = success
9085 
 
9086 
  def read(self, iprot):
9087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9089 
      return
9090 
    iprot.readStructBegin()
9091 
    while True:
9092 
      (fname, ftype, fid) = iprot.readFieldBegin()
9093 
      if ftype == TType.STOP:
9094 
        break
9095 
      if fid == 0:
9096 
        if ftype == TType.LIST:
9097 
          self.success = []
3014 chandransh 9098 
          (_etype181, _size178) = iprot.readListBegin()
9099 
          for _i182 in xrange(_size178):
9100 
            _elem183 = ReturnOrder()
9101 
            _elem183.read(iprot)
9102 
            self.success.append(_elem183)
2690 chandransh 9103 
          iprot.readListEnd()
9104 
        else:
9105 
          iprot.skip(ftype)
9106 
      else:
9107 
        iprot.skip(ftype)
9108 
      iprot.readFieldEnd()
9109 
    iprot.readStructEnd()
9110 
 
9111 
  def write(self, oprot):
9112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9114 
      return
9115 
    oprot.writeStructBegin('getReturnOrders_result')
9116 
    if self.success != None:
9117 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9118 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3014 chandransh 9119 
      for iter184 in self.success:
9120 
        iter184.write(oprot)
2690 chandransh 9121 
      oprot.writeListEnd()
9122 
      oprot.writeFieldEnd()
9123 
    oprot.writeFieldStop()
9124 
    oprot.writeStructEnd()
9125 
 
9126 
  def __repr__(self):
9127 
    L = ['%s=%r' % (key, value)
9128 
      for key, value in self.__dict__.iteritems()]
9129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9130 
 
9131 
  def __eq__(self, other):
9132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9133 
 
9134 
  def __ne__(self, other):
9135 
    return not (self == other)
9136 
 
2700 chandransh 9137 
class getReturnOrder_args:
9138 
  """
9139 
  Attributes:
9140 
   - id
9141 
  """
9142 
 
9143 
  thrift_spec = (
9144 
    None, # 0
9145 
    (1, TType.I64, 'id', None, None, ), # 1
9146 
  )
9147 
 
9148 
  def __init__(self, id=None,):
9149 
    self.id = id
9150 
 
9151 
  def read(self, iprot):
9152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9154 
      return
9155 
    iprot.readStructBegin()
9156 
    while True:
9157 
      (fname, ftype, fid) = iprot.readFieldBegin()
9158 
      if ftype == TType.STOP:
9159 
        break
9160 
      if fid == 1:
9161 
        if ftype == TType.I64:
9162 
          self.id = iprot.readI64();
9163 
        else:
9164 
          iprot.skip(ftype)
9165 
      else:
9166 
        iprot.skip(ftype)
9167 
      iprot.readFieldEnd()
9168 
    iprot.readStructEnd()
9169 
 
9170 
  def write(self, oprot):
9171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9173 
      return
9174 
    oprot.writeStructBegin('getReturnOrder_args')
9175 
    if self.id != None:
9176 
      oprot.writeFieldBegin('id', TType.I64, 1)
9177 
      oprot.writeI64(self.id)
9178 
      oprot.writeFieldEnd()
9179 
    oprot.writeFieldStop()
9180 
    oprot.writeStructEnd()
9181 
 
9182 
  def __repr__(self):
9183 
    L = ['%s=%r' % (key, value)
9184 
      for key, value in self.__dict__.iteritems()]
9185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9186 
 
9187 
  def __eq__(self, other):
9188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9189 
 
9190 
  def __ne__(self, other):
9191 
    return not (self == other)
9192 
 
9193 
class getReturnOrder_result:
9194 
  """
9195 
  Attributes:
9196 
   - success
9197 
   - ex
9198 
  """
9199 
 
9200 
  thrift_spec = (
9201 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
9202 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9203 
  )
9204 
 
9205 
  def __init__(self, success=None, ex=None,):
9206 
    self.success = success
9207 
    self.ex = ex
9208 
 
9209 
  def read(self, iprot):
9210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9212 
      return
9213 
    iprot.readStructBegin()
9214 
    while True:
9215 
      (fname, ftype, fid) = iprot.readFieldBegin()
9216 
      if ftype == TType.STOP:
9217 
        break
9218 
      if fid == 0:
9219 
        if ftype == TType.STRUCT:
9220 
          self.success = ReturnOrder()
9221 
          self.success.read(iprot)
9222 
        else:
9223 
          iprot.skip(ftype)
9224 
      elif fid == 1:
9225 
        if ftype == TType.STRUCT:
9226 
          self.ex = TransactionServiceException()
9227 
          self.ex.read(iprot)
9228 
        else:
9229 
          iprot.skip(ftype)
9230 
      else:
9231 
        iprot.skip(ftype)
9232 
      iprot.readFieldEnd()
9233 
    iprot.readStructEnd()
9234 
 
9235 
  def write(self, oprot):
9236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9238 
      return
9239 
    oprot.writeStructBegin('getReturnOrder_result')
9240 
    if self.success != None:
9241 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9242 
      self.success.write(oprot)
9243 
      oprot.writeFieldEnd()
9244 
    if self.ex != None:
9245 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9246 
      self.ex.write(oprot)
9247 
      oprot.writeFieldEnd()
9248 
    oprot.writeFieldStop()
9249 
    oprot.writeStructEnd()
9250 
 
9251 
  def __repr__(self):
9252 
    L = ['%s=%r' % (key, value)
9253 
      for key, value in self.__dict__.iteritems()]
9254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9255 
 
9256 
  def __eq__(self, other):
9257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9258 
 
9259 
  def __ne__(self, other):
9260 
    return not (self == other)
9261 
 
2690 chandransh 9262 
class processReturn_args:
9263 
  """
9264 
  Attributes:
9265 
   - returnOrderId
9266 
  """
9267 
 
9268 
  thrift_spec = (
9269 
    None, # 0
9270 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
9271 
  )
9272 
 
9273 
  def __init__(self, returnOrderId=None,):
9274 
    self.returnOrderId = returnOrderId
9275 
 
9276 
  def read(self, iprot):
9277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9279 
      return
9280 
    iprot.readStructBegin()
9281 
    while True:
9282 
      (fname, ftype, fid) = iprot.readFieldBegin()
9283 
      if ftype == TType.STOP:
9284 
        break
9285 
      if fid == 1:
9286 
        if ftype == TType.I64:
9287 
          self.returnOrderId = iprot.readI64();
9288 
        else:
9289 
          iprot.skip(ftype)
9290 
      else:
9291 
        iprot.skip(ftype)
9292 
      iprot.readFieldEnd()
9293 
    iprot.readStructEnd()
9294 
 
9295 
  def write(self, oprot):
9296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9298 
      return
9299 
    oprot.writeStructBegin('processReturn_args')
9300 
    if self.returnOrderId != None:
9301 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
9302 
      oprot.writeI64(self.returnOrderId)
9303 
      oprot.writeFieldEnd()
9304 
    oprot.writeFieldStop()
9305 
    oprot.writeStructEnd()
9306 
 
9307 
  def __repr__(self):
9308 
    L = ['%s=%r' % (key, value)
9309 
      for key, value in self.__dict__.iteritems()]
9310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9311 
 
9312 
  def __eq__(self, other):
9313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9314 
 
9315 
  def __ne__(self, other):
9316 
    return not (self == other)
9317 
 
9318 
class processReturn_result:
9319 
  """
9320 
  Attributes:
9321 
   - ex
9322 
  """
9323 
 
9324 
  thrift_spec = (
9325 
    None, # 0
9326 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9327 
  )
9328 
 
9329 
  def __init__(self, ex=None,):
9330 
    self.ex = ex
9331 
 
9332 
  def read(self, iprot):
9333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9335 
      return
9336 
    iprot.readStructBegin()
9337 
    while True:
9338 
      (fname, ftype, fid) = iprot.readFieldBegin()
9339 
      if ftype == TType.STOP:
9340 
        break
9341 
      if fid == 1:
9342 
        if ftype == TType.STRUCT:
9343 
          self.ex = TransactionServiceException()
9344 
          self.ex.read(iprot)
9345 
        else:
9346 
          iprot.skip(ftype)
9347 
      else:
9348 
        iprot.skip(ftype)
9349 
      iprot.readFieldEnd()
9350 
    iprot.readStructEnd()
9351 
 
9352 
  def write(self, oprot):
9353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9355 
      return
9356 
    oprot.writeStructBegin('processReturn_result')
9357 
    if self.ex != None:
9358 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9359 
      self.ex.write(oprot)
9360 
      oprot.writeFieldEnd()
9361 
    oprot.writeFieldStop()
9362 
    oprot.writeStructEnd()
9363 
 
9364 
  def __repr__(self):
9365 
    L = ['%s=%r' % (key, value)
9366 
      for key, value in self.__dict__.iteritems()]
9367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9368 
 
9369 
  def __eq__(self, other):
9370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9371 
 
9372 
  def __ne__(self, other):
9373 
    return not (self == other)
9374 
 
2819 chandransh 9375 
class createPurchaseOrder_args:
9376 
  """
9377 
  Attributes:
9378 
   - warehouseId
9379 
  """
2690 chandransh 9380 
 
2819 chandransh 9381 
  thrift_spec = (
9382 
    None, # 0
9383 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9384 
  )
9385 
 
9386 
  def __init__(self, warehouseId=None,):
9387 
    self.warehouseId = warehouseId
9388 
 
9389 
  def read(self, iprot):
9390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9392 
      return
9393 
    iprot.readStructBegin()
9394 
    while True:
9395 
      (fname, ftype, fid) = iprot.readFieldBegin()
9396 
      if ftype == TType.STOP:
9397 
        break
9398 
      if fid == 1:
9399 
        if ftype == TType.I64:
9400 
          self.warehouseId = iprot.readI64();
9401 
        else:
9402 
          iprot.skip(ftype)
9403 
      else:
9404 
        iprot.skip(ftype)
9405 
      iprot.readFieldEnd()
9406 
    iprot.readStructEnd()
9407 
 
9408 
  def write(self, oprot):
9409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9411 
      return
9412 
    oprot.writeStructBegin('createPurchaseOrder_args')
9413 
    if self.warehouseId != None:
9414 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9415 
      oprot.writeI64(self.warehouseId)
9416 
      oprot.writeFieldEnd()
9417 
    oprot.writeFieldStop()
9418 
    oprot.writeStructEnd()
9419 
 
9420 
  def __repr__(self):
9421 
    L = ['%s=%r' % (key, value)
9422 
      for key, value in self.__dict__.iteritems()]
9423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9424 
 
9425 
  def __eq__(self, other):
9426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9427 
 
9428 
  def __ne__(self, other):
9429 
    return not (self == other)
9430 
 
9431 
class createPurchaseOrder_result:
9432 
  """
9433 
  Attributes:
9434 
   - success
9435 
   - ex
9436 
  """
9437 
 
9438 
  thrift_spec = (
9439 
    (0, TType.I64, 'success', None, None, ), # 0
9440 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9441 
  )
9442 
 
9443 
  def __init__(self, success=None, ex=None,):
9444 
    self.success = success
9445 
    self.ex = ex
9446 
 
9447 
  def read(self, iprot):
9448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9450 
      return
9451 
    iprot.readStructBegin()
9452 
    while True:
9453 
      (fname, ftype, fid) = iprot.readFieldBegin()
9454 
      if ftype == TType.STOP:
9455 
        break
9456 
      if fid == 0:
9457 
        if ftype == TType.I64:
9458 
          self.success = iprot.readI64();
9459 
        else:
9460 
          iprot.skip(ftype)
9461 
      elif fid == 1:
9462 
        if ftype == TType.STRUCT:
9463 
          self.ex = TransactionServiceException()
9464 
          self.ex.read(iprot)
9465 
        else:
9466 
          iprot.skip(ftype)
9467 
      else:
9468 
        iprot.skip(ftype)
9469 
      iprot.readFieldEnd()
9470 
    iprot.readStructEnd()
9471 
 
9472 
  def write(self, oprot):
9473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9475 
      return
9476 
    oprot.writeStructBegin('createPurchaseOrder_result')
9477 
    if self.success != None:
9478 
      oprot.writeFieldBegin('success', TType.I64, 0)
9479 
      oprot.writeI64(self.success)
9480 
      oprot.writeFieldEnd()
9481 
    if self.ex != None:
9482 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9483 
      self.ex.write(oprot)
9484 
      oprot.writeFieldEnd()
9485 
    oprot.writeFieldStop()
9486 
    oprot.writeStructEnd()
9487 
 
9488 
  def __repr__(self):
9489 
    L = ['%s=%r' % (key, value)
9490 
      for key, value in self.__dict__.iteritems()]
9491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9492 
 
9493 
  def __eq__(self, other):
9494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9495 
 
9496 
  def __ne__(self, other):
9497 
    return not (self == other)
9498 
 
9499