Subversion Repositories SmartDukaan

Rev

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