Subversion Repositories SmartDukaan

Rev

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