Subversion Repositories SmartDukaan

Rev

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