Subversion Repositories SmartDukaan

Rev

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