Subversion Repositories SmartDukaan

Rev

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

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