Subversion Repositories SmartDukaan

Rev

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