Subversion Repositories SmartDukaan

Rev

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

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