Subversion Repositories SmartDukaan

Rev

Rev 494 | Rev 685 | 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:
19 
  def createTransaction(self, transaction):
20 
    """
21 
    Parameters:
22 
     - transaction
23 
    """
24 
    pass
25 
 
26 
  def getTransaction(self, id):
27 
    """
28 
    Parameters:
29 
     - id
30 
    """
31 
    pass
32 
 
33 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
34 
    """
35 
    Parameters:
36 
     - customerId
37 
     - from_date
38 
     - to_date
39 
     - status
40 
    """
41 
    pass
42 
 
132 ashish 43 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
44 
    """
45 
    Parameters:
46 
     - shoppingCartId
47 
    """
48 
    pass
49 
 
94 ashish 50 
  def getTransactionStatus(self, transactionId):
51 
    """
52 
    Parameters:
53 
     - transactionId
54 
    """
55 
    pass
56 
 
57 
  def changeTransactionStatus(self, transactionId, status, description):
58 
    """
59 
    Parameters:
60 
     - transactionId
61 
     - status
62 
     - description
63 
    """
64 
    pass
65 
 
483 rajveer 66 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 67 
    """
68 
    Parameters:
483 rajveer 69 
     - status
70 
     - from_date
71 
     - to_date
72 
     - warehouse_id
94 ashish 73 
    """
74 
    pass
75 
 
483 rajveer 76 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 77 
    """
78 
    Parameters:
483 rajveer 79 
     - orderId
80 
     - status
81 
     - description
94 ashish 82 
    """
83 
    pass
84 
 
642 chandransh 85 
  def addBillingDetails(self, orderId, invoice_number, jacket_number, billed_by):
494 rajveer 86 
    """
87 
    Parameters:
88 
     - orderId
89 
     - invoice_number
642 chandransh 90 
     - jacket_number
494 rajveer 91 
     - billed_by
92 
    """
93 
    pass
94 
 
483 rajveer 95 
  def getOrdersForTransaction(self, transactionId):
94 ashish 96 
    """
97 
    Parameters:
98 
     - transactionId
99 
    """
100 
    pass
101 
 
483 rajveer 102 
  def getOrdersForCustomer(self, customerId, from_date, to_date, status):
94 ashish 103 
    """
104 
    Parameters:
483 rajveer 105 
     - customerId
106 
     - from_date
107 
     - to_date
108 
     - status
94 ashish 109 
    """
110 
    pass
111 
 
483 rajveer 112 
  def createOrder(self, order):
94 ashish 113 
    """
114 
    Parameters:
483 rajveer 115 
     - order
94 ashish 116 
    """
117 
    pass
118 
 
483 rajveer 119 
  def getOrder(self, id):
94 ashish 120 
    """
121 
    Parameters:
483 rajveer 122 
     - id
94 ashish 123 
    """
124 
    pass
125 
 
483 rajveer 126 
  def getLineItemsForOrder(self, orderId):
94 ashish 127 
    """
128 
    Parameters:
483 rajveer 129 
     - orderId
94 ashish 130 
    """
131 
    pass
132 
 
483 rajveer 133 
  def getAlerts(self, orderId, valid):
94 ashish 134 
    """
135 
    Parameters:
483 rajveer 136 
     - orderId
304 ashish 137 
     - valid
138 
    """
139 
    pass
94 ashish 140 
 
483 rajveer 141 
  def setAlert(self, orderId, unset, type, comment):
304 ashish 142 
    """
143 
    Parameters:
483 rajveer 144 
     - orderId
304 ashish 145 
     - unset
146 
     - type
147 
     - comment
148 
    """
149 
    pass
150 
 
151 
 
94 ashish 152 
class Client(Iface):
153 
  def __init__(self, iprot, oprot=None):
154 
    self._iprot = self._oprot = iprot
155 
    if oprot != None:
156 
      self._oprot = oprot
157 
    self._seqid = 0
158 
 
159 
  def createTransaction(self, transaction):
160 
    """
161 
    Parameters:
162 
     - transaction
163 
    """
164 
    self.send_createTransaction(transaction)
132 ashish 165 
    return self.recv_createTransaction()
94 ashish 166 
 
167 
  def send_createTransaction(self, transaction):
168 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
169 
    args = createTransaction_args()
170 
    args.transaction = transaction
171 
    args.write(self._oprot)
172 
    self._oprot.writeMessageEnd()
173 
    self._oprot.trans.flush()
174 
 
175 
  def recv_createTransaction(self, ):
176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
177 
    if mtype == TMessageType.EXCEPTION:
178 
      x = TApplicationException()
179 
      x.read(self._iprot)
180 
      self._iprot.readMessageEnd()
181 
      raise x
182 
    result = createTransaction_result()
183 
    result.read(self._iprot)
184 
    self._iprot.readMessageEnd()
132 ashish 185 
    if result.success != None:
186 
      return result.success
94 ashish 187 
    if result.ex != None:
188 
      raise result.ex
132 ashish 189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 190 
 
191 
  def getTransaction(self, id):
192 
    """
193 
    Parameters:
194 
     - id
195 
    """
196 
    self.send_getTransaction(id)
197 
    return self.recv_getTransaction()
198 
 
199 
  def send_getTransaction(self, id):
200 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
201 
    args = getTransaction_args()
202 
    args.id = id
203 
    args.write(self._oprot)
204 
    self._oprot.writeMessageEnd()
205 
    self._oprot.trans.flush()
206 
 
207 
  def recv_getTransaction(self, ):
208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
209 
    if mtype == TMessageType.EXCEPTION:
210 
      x = TApplicationException()
211 
      x.read(self._iprot)
212 
      self._iprot.readMessageEnd()
213 
      raise x
214 
    result = getTransaction_result()
215 
    result.read(self._iprot)
216 
    self._iprot.readMessageEnd()
217 
    if result.success != None:
218 
      return result.success
219 
    if result.ex != None:
220 
      raise result.ex
221 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
222 
 
223 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
224 
    """
225 
    Parameters:
226 
     - customerId
227 
     - from_date
228 
     - to_date
229 
     - status
230 
    """
231 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
232 
    return self.recv_getTransactionsForCustomer()
233 
 
234 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
235 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
236 
    args = getTransactionsForCustomer_args()
237 
    args.customerId = customerId
238 
    args.from_date = from_date
239 
    args.to_date = to_date
240 
    args.status = status
241 
    args.write(self._oprot)
242 
    self._oprot.writeMessageEnd()
243 
    self._oprot.trans.flush()
244 
 
245 
  def recv_getTransactionsForCustomer(self, ):
246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
247 
    if mtype == TMessageType.EXCEPTION:
248 
      x = TApplicationException()
249 
      x.read(self._iprot)
250 
      self._iprot.readMessageEnd()
251 
      raise x
252 
    result = getTransactionsForCustomer_result()
253 
    result.read(self._iprot)
254 
    self._iprot.readMessageEnd()
255 
    if result.success != None:
256 
      return result.success
257 
    if result.ex != None:
258 
      raise result.ex
259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
260 
 
132 ashish 261 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
262 
    """
263 
    Parameters:
264 
     - shoppingCartId
265 
    """
266 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
267 
    return self.recv_getTransactionsForShoppingCartId()
268 
 
269 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
270 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
271 
    args = getTransactionsForShoppingCartId_args()
272 
    args.shoppingCartId = shoppingCartId
273 
    args.write(self._oprot)
274 
    self._oprot.writeMessageEnd()
275 
    self._oprot.trans.flush()
276 
 
277 
  def recv_getTransactionsForShoppingCartId(self, ):
278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
279 
    if mtype == TMessageType.EXCEPTION:
280 
      x = TApplicationException()
281 
      x.read(self._iprot)
282 
      self._iprot.readMessageEnd()
283 
      raise x
284 
    result = getTransactionsForShoppingCartId_result()
285 
    result.read(self._iprot)
286 
    self._iprot.readMessageEnd()
287 
    if result.success != None:
288 
      return result.success
289 
    if result.ex != None:
290 
      raise result.ex
291 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
292 
 
94 ashish 293 
  def getTransactionStatus(self, transactionId):
294 
    """
295 
    Parameters:
296 
     - transactionId
297 
    """
298 
    self.send_getTransactionStatus(transactionId)
299 
    return self.recv_getTransactionStatus()
300 
 
301 
  def send_getTransactionStatus(self, transactionId):
302 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
303 
    args = getTransactionStatus_args()
304 
    args.transactionId = transactionId
305 
    args.write(self._oprot)
306 
    self._oprot.writeMessageEnd()
307 
    self._oprot.trans.flush()
308 
 
309 
  def recv_getTransactionStatus(self, ):
310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
311 
    if mtype == TMessageType.EXCEPTION:
312 
      x = TApplicationException()
313 
      x.read(self._iprot)
314 
      self._iprot.readMessageEnd()
315 
      raise x
316 
    result = getTransactionStatus_result()
317 
    result.read(self._iprot)
318 
    self._iprot.readMessageEnd()
319 
    if result.success != None:
320 
      return result.success
321 
    if result.ex != None:
322 
      raise result.ex
323 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
324 
 
325 
  def changeTransactionStatus(self, transactionId, status, description):
326 
    """
327 
    Parameters:
328 
     - transactionId
329 
     - status
330 
     - description
331 
    """
332 
    self.send_changeTransactionStatus(transactionId, status, description)
333 
    return self.recv_changeTransactionStatus()
334 
 
335 
  def send_changeTransactionStatus(self, transactionId, status, description):
336 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
337 
    args = changeTransactionStatus_args()
338 
    args.transactionId = transactionId
339 
    args.status = status
340 
    args.description = description
341 
    args.write(self._oprot)
342 
    self._oprot.writeMessageEnd()
343 
    self._oprot.trans.flush()
344 
 
345 
  def recv_changeTransactionStatus(self, ):
346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
347 
    if mtype == TMessageType.EXCEPTION:
348 
      x = TApplicationException()
349 
      x.read(self._iprot)
350 
      self._iprot.readMessageEnd()
351 
      raise x
352 
    result = changeTransactionStatus_result()
353 
    result.read(self._iprot)
354 
    self._iprot.readMessageEnd()
355 
    if result.success != None:
356 
      return result.success
357 
    if result.ex != None:
358 
      raise result.ex
359 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
360 
 
483 rajveer 361 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 362 
    """
363 
    Parameters:
483 rajveer 364 
     - status
365 
     - from_date
366 
     - to_date
367 
     - warehouse_id
94 ashish 368 
    """
483 rajveer 369 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
370 
    return self.recv_getAllOrders()
94 ashish 371 
 
483 rajveer 372 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
373 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
374 
    args = getAllOrders_args()
375 
    args.status = status
376 
    args.from_date = from_date
377 
    args.to_date = to_date
378 
    args.warehouse_id = warehouse_id
94 ashish 379 
    args.write(self._oprot)
380 
    self._oprot.writeMessageEnd()
381 
    self._oprot.trans.flush()
382 
 
483 rajveer 383 
  def recv_getAllOrders(self, ):
94 ashish 384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
385 
    if mtype == TMessageType.EXCEPTION:
386 
      x = TApplicationException()
387 
      x.read(self._iprot)
388 
      self._iprot.readMessageEnd()
389 
      raise x
483 rajveer 390 
    result = getAllOrders_result()
94 ashish 391 
    result.read(self._iprot)
392 
    self._iprot.readMessageEnd()
393 
    if result.success != None:
394 
      return result.success
395 
    if result.ex != None:
396 
      raise result.ex
483 rajveer 397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 398 
 
483 rajveer 399 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 400 
    """
401 
    Parameters:
483 rajveer 402 
     - orderId
403 
     - status
404 
     - description
94 ashish 405 
    """
483 rajveer 406 
    self.send_changeOrderStatus(orderId, status, description)
407 
    return self.recv_changeOrderStatus()
94 ashish 408 
 
483 rajveer 409 
  def send_changeOrderStatus(self, orderId, status, description):
410 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
411 
    args = changeOrderStatus_args()
412 
    args.orderId = orderId
413 
    args.status = status
414 
    args.description = description
94 ashish 415 
    args.write(self._oprot)
416 
    self._oprot.writeMessageEnd()
417 
    self._oprot.trans.flush()
418 
 
483 rajveer 419 
  def recv_changeOrderStatus(self, ):
94 ashish 420 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
421 
    if mtype == TMessageType.EXCEPTION:
422 
      x = TApplicationException()
423 
      x.read(self._iprot)
424 
      self._iprot.readMessageEnd()
425 
      raise x
483 rajveer 426 
    result = changeOrderStatus_result()
94 ashish 427 
    result.read(self._iprot)
428 
    self._iprot.readMessageEnd()
429 
    if result.success != None:
430 
      return result.success
431 
    if result.ex != None:
432 
      raise result.ex
483 rajveer 433 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 434 
 
642 chandransh 435 
  def addBillingDetails(self, orderId, invoice_number, jacket_number, billed_by):
494 rajveer 436 
    """
437 
    Parameters:
438 
     - orderId
439 
     - invoice_number
642 chandransh 440 
     - jacket_number
494 rajveer 441 
     - billed_by
442 
    """
642 chandransh 443 
    self.send_addBillingDetails(orderId, invoice_number, jacket_number, billed_by)
494 rajveer 444 
    return self.recv_addBillingDetails()
445 
 
642 chandransh 446 
  def send_addBillingDetails(self, orderId, invoice_number, jacket_number, billed_by):
494 rajveer 447 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
448 
    args = addBillingDetails_args()
449 
    args.orderId = orderId
450 
    args.invoice_number = invoice_number
642 chandransh 451 
    args.jacket_number = jacket_number
494 rajveer 452 
    args.billed_by = billed_by
453 
    args.write(self._oprot)
454 
    self._oprot.writeMessageEnd()
455 
    self._oprot.trans.flush()
456 
 
457 
  def recv_addBillingDetails(self, ):
458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
459 
    if mtype == TMessageType.EXCEPTION:
460 
      x = TApplicationException()
461 
      x.read(self._iprot)
462 
      self._iprot.readMessageEnd()
463 
      raise x
464 
    result = addBillingDetails_result()
465 
    result.read(self._iprot)
466 
    self._iprot.readMessageEnd()
467 
    if result.success != None:
468 
      return result.success
469 
    if result.ex != None:
470 
      raise result.ex
471 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
472 
 
483 rajveer 473 
  def getOrdersForTransaction(self, transactionId):
94 ashish 474 
    """
475 
    Parameters:
476 
     - transactionId
477 
    """
483 rajveer 478 
    self.send_getOrdersForTransaction(transactionId)
479 
    return self.recv_getOrdersForTransaction()
94 ashish 480 
 
483 rajveer 481 
  def send_getOrdersForTransaction(self, transactionId):
482 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
483 
    args = getOrdersForTransaction_args()
94 ashish 484 
    args.transactionId = transactionId
485 
    args.write(self._oprot)
486 
    self._oprot.writeMessageEnd()
487 
    self._oprot.trans.flush()
488 
 
483 rajveer 489 
  def recv_getOrdersForTransaction(self, ):
94 ashish 490 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
491 
    if mtype == TMessageType.EXCEPTION:
492 
      x = TApplicationException()
493 
      x.read(self._iprot)
494 
      self._iprot.readMessageEnd()
495 
      raise x
483 rajveer 496 
    result = getOrdersForTransaction_result()
94 ashish 497 
    result.read(self._iprot)
498 
    self._iprot.readMessageEnd()
499 
    if result.success != None:
500 
      return result.success
501 
    if result.ex != None:
502 
      raise result.ex
483 rajveer 503 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 504 
 
483 rajveer 505 
  def getOrdersForCustomer(self, customerId, from_date, to_date, status):
94 ashish 506 
    """
507 
    Parameters:
483 rajveer 508 
     - customerId
509 
     - from_date
510 
     - to_date
511 
     - status
94 ashish 512 
    """
483 rajveer 513 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, status)
514 
    return self.recv_getOrdersForCustomer()
94 ashish 515 
 
483 rajveer 516 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, status):
517 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
518 
    args = getOrdersForCustomer_args()
519 
    args.customerId = customerId
520 
    args.from_date = from_date
521 
    args.to_date = to_date
522 
    args.status = status
94 ashish 523 
    args.write(self._oprot)
524 
    self._oprot.writeMessageEnd()
525 
    self._oprot.trans.flush()
526 
 
483 rajveer 527 
  def recv_getOrdersForCustomer(self, ):
94 ashish 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
483 rajveer 534 
    result = getOrdersForCustomer_result()
94 ashish 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
483 rajveer 541 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 542 
 
483 rajveer 543 
  def createOrder(self, order):
94 ashish 544 
    """
545 
    Parameters:
483 rajveer 546 
     - order
94 ashish 547 
    """
483 rajveer 548 
    self.send_createOrder(order)
549 
    return self.recv_createOrder()
94 ashish 550 
 
483 rajveer 551 
  def send_createOrder(self, order):
552 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
553 
    args = createOrder_args()
554 
    args.order = order
94 ashish 555 
    args.write(self._oprot)
556 
    self._oprot.writeMessageEnd()
557 
    self._oprot.trans.flush()
558 
 
483 rajveer 559 
  def recv_createOrder(self, ):
94 ashish 560 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
561 
    if mtype == TMessageType.EXCEPTION:
562 
      x = TApplicationException()
563 
      x.read(self._iprot)
564 
      self._iprot.readMessageEnd()
565 
      raise x
483 rajveer 566 
    result = createOrder_result()
94 ashish 567 
    result.read(self._iprot)
568 
    self._iprot.readMessageEnd()
569 
    if result.success != None:
570 
      return result.success
571 
    if result.ex != None:
572 
      raise result.ex
483 rajveer 573 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 574 
 
483 rajveer 575 
  def getOrder(self, id):
94 ashish 576 
    """
577 
    Parameters:
483 rajveer 578 
     - id
94 ashish 579 
    """
483 rajveer 580 
    self.send_getOrder(id)
581 
    return self.recv_getOrder()
94 ashish 582 
 
483 rajveer 583 
  def send_getOrder(self, id):
584 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
585 
    args = getOrder_args()
586 
    args.id = id
94 ashish 587 
    args.write(self._oprot)
588 
    self._oprot.writeMessageEnd()
589 
    self._oprot.trans.flush()
590 
 
483 rajveer 591 
  def recv_getOrder(self, ):
94 ashish 592 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
593 
    if mtype == TMessageType.EXCEPTION:
594 
      x = TApplicationException()
595 
      x.read(self._iprot)
596 
      self._iprot.readMessageEnd()
597 
      raise x
483 rajveer 598 
    result = getOrder_result()
94 ashish 599 
    result.read(self._iprot)
600 
    self._iprot.readMessageEnd()
601 
    if result.success != None:
602 
      return result.success
603 
    if result.ex != None:
604 
      raise result.ex
483 rajveer 605 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 606 
 
483 rajveer 607 
  def getLineItemsForOrder(self, orderId):
94 ashish 608 
    """
609 
    Parameters:
483 rajveer 610 
     - orderId
94 ashish 611 
    """
483 rajveer 612 
    self.send_getLineItemsForOrder(orderId)
613 
    return self.recv_getLineItemsForOrder()
94 ashish 614 
 
483 rajveer 615 
  def send_getLineItemsForOrder(self, orderId):
616 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
617 
    args = getLineItemsForOrder_args()
618 
    args.orderId = orderId
94 ashish 619 
    args.write(self._oprot)
620 
    self._oprot.writeMessageEnd()
621 
    self._oprot.trans.flush()
622 
 
483 rajveer 623 
  def recv_getLineItemsForOrder(self, ):
94 ashish 624 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
625 
    if mtype == TMessageType.EXCEPTION:
626 
      x = TApplicationException()
627 
      x.read(self._iprot)
628 
      self._iprot.readMessageEnd()
629 
      raise x
483 rajveer 630 
    result = getLineItemsForOrder_result()
94 ashish 631 
    result.read(self._iprot)
632 
    self._iprot.readMessageEnd()
633 
    if result.success != None:
634 
      return result.success
635 
    if result.ex != None:
636 
      raise result.ex
483 rajveer 637 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 638 
 
483 rajveer 639 
  def getAlerts(self, orderId, valid):
94 ashish 640 
    """
641 
    Parameters:
483 rajveer 642 
     - orderId
304 ashish 643 
     - valid
644 
    """
483 rajveer 645 
    self.send_getAlerts(orderId, valid)
304 ashish 646 
    return self.recv_getAlerts()
94 ashish 647 
 
483 rajveer 648 
  def send_getAlerts(self, orderId, valid):
304 ashish 649 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
650 
    args = getAlerts_args()
483 rajveer 651 
    args.orderId = orderId
304 ashish 652 
    args.valid = valid
653 
    args.write(self._oprot)
654 
    self._oprot.writeMessageEnd()
655 
    self._oprot.trans.flush()
656 
 
657 
  def recv_getAlerts(self, ):
658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
659 
    if mtype == TMessageType.EXCEPTION:
660 
      x = TApplicationException()
661 
      x.read(self._iprot)
662 
      self._iprot.readMessageEnd()
663 
      raise x
664 
    result = getAlerts_result()
665 
    result.read(self._iprot)
666 
    self._iprot.readMessageEnd()
667 
    if result.success != None:
668 
      return result.success
669 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
670 
 
483 rajveer 671 
  def setAlert(self, orderId, unset, type, comment):
304 ashish 672 
    """
673 
    Parameters:
483 rajveer 674 
     - orderId
304 ashish 675 
     - unset
676 
     - type
677 
     - comment
678 
    """
483 rajveer 679 
    self.send_setAlert(orderId, unset, type, comment)
304 ashish 680 
    self.recv_setAlert()
681 
 
483 rajveer 682 
  def send_setAlert(self, orderId, unset, type, comment):
304 ashish 683 
    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
684 
    args = setAlert_args()
483 rajveer 685 
    args.orderId = orderId
304 ashish 686 
    args.unset = unset
687 
    args.type = type
688 
    args.comment = comment
689 
    args.write(self._oprot)
690 
    self._oprot.writeMessageEnd()
691 
    self._oprot.trans.flush()
692 
 
693 
  def recv_setAlert(self, ):
694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
695 
    if mtype == TMessageType.EXCEPTION:
696 
      x = TApplicationException()
697 
      x.read(self._iprot)
698 
      self._iprot.readMessageEnd()
699 
      raise x
700 
    result = setAlert_result()
701 
    result.read(self._iprot)
702 
    self._iprot.readMessageEnd()
703 
    return
704 
 
705 
 
94 ashish 706 
class Processor(Iface, TProcessor):
707 
  def __init__(self, handler):
708 
    self._handler = handler
709 
    self._processMap = {}
710 
    self._processMap["createTransaction"] = Processor.process_createTransaction
711 
    self._processMap["getTransaction"] = Processor.process_getTransaction
712 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 713 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 714 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
715 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
483 rajveer 716 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
717 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
494 rajveer 718 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
483 rajveer 719 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
720 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
721 
    self._processMap["createOrder"] = Processor.process_createOrder
722 
    self._processMap["getOrder"] = Processor.process_getOrder
723 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
304 ashish 724 
    self._processMap["getAlerts"] = Processor.process_getAlerts
725 
    self._processMap["setAlert"] = Processor.process_setAlert
94 ashish 726 
 
727 
  def process(self, iprot, oprot):
728 
    (name, type, seqid) = iprot.readMessageBegin()
729 
    if name not in self._processMap:
730 
      iprot.skip(TType.STRUCT)
731 
      iprot.readMessageEnd()
732 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
733 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
734 
      x.write(oprot)
735 
      oprot.writeMessageEnd()
736 
      oprot.trans.flush()
737 
      return
738 
    else:
739 
      self._processMap[name](self, seqid, iprot, oprot)
740 
    return True
741 
 
742 
  def process_createTransaction(self, seqid, iprot, oprot):
743 
    args = createTransaction_args()
744 
    args.read(iprot)
745 
    iprot.readMessageEnd()
746 
    result = createTransaction_result()
747 
    try:
132 ashish 748 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 749 
    except TransactionServiceException, ex:
750 
      result.ex = ex
751 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
752 
    result.write(oprot)
753 
    oprot.writeMessageEnd()
754 
    oprot.trans.flush()
755 
 
756 
  def process_getTransaction(self, seqid, iprot, oprot):
757 
    args = getTransaction_args()
758 
    args.read(iprot)
759 
    iprot.readMessageEnd()
760 
    result = getTransaction_result()
761 
    try:
762 
      result.success = self._handler.getTransaction(args.id)
763 
    except TransactionServiceException, ex:
764 
      result.ex = ex
765 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
766 
    result.write(oprot)
767 
    oprot.writeMessageEnd()
768 
    oprot.trans.flush()
769 
 
770 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
771 
    args = getTransactionsForCustomer_args()
772 
    args.read(iprot)
773 
    iprot.readMessageEnd()
774 
    result = getTransactionsForCustomer_result()
775 
    try:
776 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
777 
    except TransactionServiceException, ex:
778 
      result.ex = ex
779 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
780 
    result.write(oprot)
781 
    oprot.writeMessageEnd()
782 
    oprot.trans.flush()
783 
 
132 ashish 784 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
785 
    args = getTransactionsForShoppingCartId_args()
786 
    args.read(iprot)
787 
    iprot.readMessageEnd()
788 
    result = getTransactionsForShoppingCartId_result()
789 
    try:
790 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
791 
    except TransactionServiceException, ex:
792 
      result.ex = ex
793 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
794 
    result.write(oprot)
795 
    oprot.writeMessageEnd()
796 
    oprot.trans.flush()
797 
 
94 ashish 798 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
799 
    args = getTransactionStatus_args()
800 
    args.read(iprot)
801 
    iprot.readMessageEnd()
802 
    result = getTransactionStatus_result()
803 
    try:
804 
      result.success = self._handler.getTransactionStatus(args.transactionId)
805 
    except TransactionServiceException, ex:
806 
      result.ex = ex
807 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
808 
    result.write(oprot)
809 
    oprot.writeMessageEnd()
810 
    oprot.trans.flush()
811 
 
812 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
813 
    args = changeTransactionStatus_args()
814 
    args.read(iprot)
815 
    iprot.readMessageEnd()
816 
    result = changeTransactionStatus_result()
817 
    try:
818 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
819 
    except TransactionServiceException, ex:
820 
      result.ex = ex
821 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
822 
    result.write(oprot)
823 
    oprot.writeMessageEnd()
824 
    oprot.trans.flush()
825 
 
483 rajveer 826 
  def process_getAllOrders(self, seqid, iprot, oprot):
827 
    args = getAllOrders_args()
94 ashish 828 
    args.read(iprot)
829 
    iprot.readMessageEnd()
483 rajveer 830 
    result = getAllOrders_result()
94 ashish 831 
    try:
483 rajveer 832 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 833 
    except TransactionServiceException, ex:
834 
      result.ex = ex
483 rajveer 835 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 836 
    result.write(oprot)
837 
    oprot.writeMessageEnd()
838 
    oprot.trans.flush()
839 
 
483 rajveer 840 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
841 
    args = changeOrderStatus_args()
94 ashish 842 
    args.read(iprot)
843 
    iprot.readMessageEnd()
483 rajveer 844 
    result = changeOrderStatus_result()
94 ashish 845 
    try:
483 rajveer 846 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 847 
    except TransactionServiceException, ex:
848 
      result.ex = ex
483 rajveer 849 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 850 
    result.write(oprot)
851 
    oprot.writeMessageEnd()
852 
    oprot.trans.flush()
853 
 
494 rajveer 854 
  def process_addBillingDetails(self, seqid, iprot, oprot):
855 
    args = addBillingDetails_args()
856 
    args.read(iprot)
857 
    iprot.readMessageEnd()
858 
    result = addBillingDetails_result()
859 
    try:
642 chandransh 860 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.jacket_number, args.billed_by)
494 rajveer 861 
    except TransactionServiceException, ex:
862 
      result.ex = ex
863 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
864 
    result.write(oprot)
865 
    oprot.writeMessageEnd()
866 
    oprot.trans.flush()
867 
 
483 rajveer 868 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
869 
    args = getOrdersForTransaction_args()
94 ashish 870 
    args.read(iprot)
871 
    iprot.readMessageEnd()
483 rajveer 872 
    result = getOrdersForTransaction_result()
94 ashish 873 
    try:
483 rajveer 874 
      result.success = self._handler.getOrdersForTransaction(args.transactionId)
94 ashish 875 
    except TransactionServiceException, ex:
876 
      result.ex = ex
483 rajveer 877 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 878 
    result.write(oprot)
879 
    oprot.writeMessageEnd()
880 
    oprot.trans.flush()
881 
 
483 rajveer 882 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
883 
    args = getOrdersForCustomer_args()
94 ashish 884 
    args.read(iprot)
885 
    iprot.readMessageEnd()
483 rajveer 886 
    result = getOrdersForCustomer_result()
94 ashish 887 
    try:
483 rajveer 888 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.status)
94 ashish 889 
    except TransactionServiceException, ex:
890 
      result.ex = ex
483 rajveer 891 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 892 
    result.write(oprot)
893 
    oprot.writeMessageEnd()
894 
    oprot.trans.flush()
895 
 
483 rajveer 896 
  def process_createOrder(self, seqid, iprot, oprot):
897 
    args = createOrder_args()
94 ashish 898 
    args.read(iprot)
899 
    iprot.readMessageEnd()
483 rajveer 900 
    result = createOrder_result()
94 ashish 901 
    try:
483 rajveer 902 
      result.success = self._handler.createOrder(args.order)
94 ashish 903 
    except TransactionServiceException, ex:
904 
      result.ex = ex
483 rajveer 905 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 906 
    result.write(oprot)
907 
    oprot.writeMessageEnd()
908 
    oprot.trans.flush()
909 
 
483 rajveer 910 
  def process_getOrder(self, seqid, iprot, oprot):
911 
    args = getOrder_args()
94 ashish 912 
    args.read(iprot)
913 
    iprot.readMessageEnd()
483 rajveer 914 
    result = getOrder_result()
94 ashish 915 
    try:
483 rajveer 916 
      result.success = self._handler.getOrder(args.id)
94 ashish 917 
    except TransactionServiceException, ex:
918 
      result.ex = ex
483 rajveer 919 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 920 
    result.write(oprot)
921 
    oprot.writeMessageEnd()
922 
    oprot.trans.flush()
923 
 
483 rajveer 924 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
925 
    args = getLineItemsForOrder_args()
94 ashish 926 
    args.read(iprot)
927 
    iprot.readMessageEnd()
483 rajveer 928 
    result = getLineItemsForOrder_result()
94 ashish 929 
    try:
483 rajveer 930 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 931 
    except TransactionServiceException, ex:
932 
      result.ex = ex
483 rajveer 933 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 934 
    result.write(oprot)
935 
    oprot.writeMessageEnd()
936 
    oprot.trans.flush()
937 
 
304 ashish 938 
  def process_getAlerts(self, seqid, iprot, oprot):
939 
    args = getAlerts_args()
940 
    args.read(iprot)
941 
    iprot.readMessageEnd()
942 
    result = getAlerts_result()
483 rajveer 943 
    result.success = self._handler.getAlerts(args.orderId, args.valid)
304 ashish 944 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
945 
    result.write(oprot)
946 
    oprot.writeMessageEnd()
947 
    oprot.trans.flush()
94 ashish 948 
 
304 ashish 949 
  def process_setAlert(self, seqid, iprot, oprot):
950 
    args = setAlert_args()
951 
    args.read(iprot)
952 
    iprot.readMessageEnd()
953 
    result = setAlert_result()
483 rajveer 954 
    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
304 ashish 955 
    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
956 
    result.write(oprot)
957 
    oprot.writeMessageEnd()
958 
    oprot.trans.flush()
959 
 
960 
 
94 ashish 961 
# HELPER FUNCTIONS AND STRUCTURES
962 
 
963 
class createTransaction_args:
964 
  """
965 
  Attributes:
966 
   - transaction
967 
  """
968 
 
969 
  thrift_spec = (
970 
    None, # 0
971 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
972 
  )
973 
 
974 
  def __init__(self, transaction=None,):
975 
    self.transaction = transaction
976 
 
977 
  def read(self, iprot):
978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
980 
      return
981 
    iprot.readStructBegin()
982 
    while True:
983 
      (fname, ftype, fid) = iprot.readFieldBegin()
984 
      if ftype == TType.STOP:
985 
        break
986 
      if fid == 1:
987 
        if ftype == TType.STRUCT:
988 
          self.transaction = Transaction()
989 
          self.transaction.read(iprot)
990 
        else:
991 
          iprot.skip(ftype)
992 
      else:
993 
        iprot.skip(ftype)
994 
      iprot.readFieldEnd()
995 
    iprot.readStructEnd()
996 
 
997 
  def write(self, oprot):
998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1000 
      return
1001 
    oprot.writeStructBegin('createTransaction_args')
1002 
    if self.transaction != None:
1003 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
1004 
      self.transaction.write(oprot)
1005 
      oprot.writeFieldEnd()
1006 
    oprot.writeFieldStop()
1007 
    oprot.writeStructEnd()
1008 
 
1009 
  def __repr__(self):
1010 
    L = ['%s=%r' % (key, value)
1011 
      for key, value in self.__dict__.iteritems()]
1012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1013 
 
1014 
  def __eq__(self, other):
1015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1016 
 
1017 
  def __ne__(self, other):
1018 
    return not (self == other)
1019 
 
1020 
class createTransaction_result:
1021 
  """
1022 
  Attributes:
132 ashish 1023 
   - success
94 ashish 1024 
   - ex
1025 
  """
1026 
 
1027 
  thrift_spec = (
132 ashish 1028 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 1029 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1030 
  )
1031 
 
132 ashish 1032 
  def __init__(self, success=None, ex=None,):
1033 
    self.success = success
94 ashish 1034 
    self.ex = ex
1035 
 
1036 
  def read(self, iprot):
1037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1039 
      return
1040 
    iprot.readStructBegin()
1041 
    while True:
1042 
      (fname, ftype, fid) = iprot.readFieldBegin()
1043 
      if ftype == TType.STOP:
1044 
        break
132 ashish 1045 
      if fid == 0:
1046 
        if ftype == TType.I64:
1047 
          self.success = iprot.readI64();
1048 
        else:
1049 
          iprot.skip(ftype)
1050 
      elif fid == 1:
94 ashish 1051 
        if ftype == TType.STRUCT:
1052 
          self.ex = TransactionServiceException()
1053 
          self.ex.read(iprot)
1054 
        else:
1055 
          iprot.skip(ftype)
1056 
      else:
1057 
        iprot.skip(ftype)
1058 
      iprot.readFieldEnd()
1059 
    iprot.readStructEnd()
1060 
 
1061 
  def write(self, oprot):
1062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1064 
      return
1065 
    oprot.writeStructBegin('createTransaction_result')
132 ashish 1066 
    if self.success != None:
1067 
      oprot.writeFieldBegin('success', TType.I64, 0)
1068 
      oprot.writeI64(self.success)
1069 
      oprot.writeFieldEnd()
94 ashish 1070 
    if self.ex != None:
1071 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
1072 
      self.ex.write(oprot)
1073 
      oprot.writeFieldEnd()
1074 
    oprot.writeFieldStop()
1075 
    oprot.writeStructEnd()
1076 
 
1077 
  def __repr__(self):
1078 
    L = ['%s=%r' % (key, value)
1079 
      for key, value in self.__dict__.iteritems()]
1080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1081 
 
1082 
  def __eq__(self, other):
1083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1084 
 
1085 
  def __ne__(self, other):
1086 
    return not (self == other)
1087 
 
1088 
class getTransaction_args:
1089 
  """
1090 
  Attributes:
1091 
   - id
1092 
  """
1093 
 
1094 
  thrift_spec = (
1095 
    None, # 0
1096 
    (1, TType.I64, 'id', None, None, ), # 1
1097 
  )
1098 
 
1099 
  def __init__(self, id=None,):
1100 
    self.id = id
1101 
 
1102 
  def read(self, iprot):
1103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1105 
      return
1106 
    iprot.readStructBegin()
1107 
    while True:
1108 
      (fname, ftype, fid) = iprot.readFieldBegin()
1109 
      if ftype == TType.STOP:
1110 
        break
1111 
      if fid == 1:
1112 
        if ftype == TType.I64:
1113 
          self.id = iprot.readI64();
1114 
        else:
1115 
          iprot.skip(ftype)
1116 
      else:
1117 
        iprot.skip(ftype)
1118 
      iprot.readFieldEnd()
1119 
    iprot.readStructEnd()
1120 
 
1121 
  def write(self, oprot):
1122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1124 
      return
1125 
    oprot.writeStructBegin('getTransaction_args')
1126 
    if self.id != None:
1127 
      oprot.writeFieldBegin('id', TType.I64, 1)
1128 
      oprot.writeI64(self.id)
1129 
      oprot.writeFieldEnd()
1130 
    oprot.writeFieldStop()
1131 
    oprot.writeStructEnd()
1132 
 
1133 
  def __repr__(self):
1134 
    L = ['%s=%r' % (key, value)
1135 
      for key, value in self.__dict__.iteritems()]
1136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1137 
 
1138 
  def __eq__(self, other):
1139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1140 
 
1141 
  def __ne__(self, other):
1142 
    return not (self == other)
1143 
 
1144 
class getTransaction_result:
1145 
  """
1146 
  Attributes:
1147 
   - success
1148 
   - ex
1149 
  """
1150 
 
1151 
  thrift_spec = (
1152 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
1153 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1154 
  )
1155 
 
1156 
  def __init__(self, success=None, ex=None,):
1157 
    self.success = success
1158 
    self.ex = ex
1159 
 
1160 
  def read(self, iprot):
1161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1163 
      return
1164 
    iprot.readStructBegin()
1165 
    while True:
1166 
      (fname, ftype, fid) = iprot.readFieldBegin()
1167 
      if ftype == TType.STOP:
1168 
        break
1169 
      if fid == 0:
1170 
        if ftype == TType.STRUCT:
1171 
          self.success = Transaction()
1172 
          self.success.read(iprot)
1173 
        else:
1174 
          iprot.skip(ftype)
1175 
      elif fid == 1:
1176 
        if ftype == TType.STRUCT:
1177 
          self.ex = TransactionServiceException()
1178 
          self.ex.read(iprot)
1179 
        else:
1180 
          iprot.skip(ftype)
1181 
      else:
1182 
        iprot.skip(ftype)
1183 
      iprot.readFieldEnd()
1184 
    iprot.readStructEnd()
1185 
 
1186 
  def write(self, oprot):
1187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1189 
      return
1190 
    oprot.writeStructBegin('getTransaction_result')
1191 
    if self.success != None:
1192 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1193 
      self.success.write(oprot)
1194 
      oprot.writeFieldEnd()
1195 
    if self.ex != None:
1196 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
1197 
      self.ex.write(oprot)
1198 
      oprot.writeFieldEnd()
1199 
    oprot.writeFieldStop()
1200 
    oprot.writeStructEnd()
1201 
 
1202 
  def __repr__(self):
1203 
    L = ['%s=%r' % (key, value)
1204 
      for key, value in self.__dict__.iteritems()]
1205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1206 
 
1207 
  def __eq__(self, other):
1208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1209 
 
1210 
  def __ne__(self, other):
1211 
    return not (self == other)
1212 
 
1213 
class getTransactionsForCustomer_args:
1214 
  """
1215 
  Attributes:
1216 
   - customerId
1217 
   - from_date
1218 
   - to_date
1219 
   - status
1220 
  """
1221 
 
1222 
  thrift_spec = (
1223 
    None, # 0
1224 
    (1, TType.I64, 'customerId', None, None, ), # 1
1225 
    (2, TType.I64, 'from_date', None, None, ), # 2
1226 
    (3, TType.I64, 'to_date', None, None, ), # 3
1227 
    (4, TType.I32, 'status', None, None, ), # 4
1228 
  )
1229 
 
1230 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
1231 
    self.customerId = customerId
1232 
    self.from_date = from_date
1233 
    self.to_date = to_date
1234 
    self.status = status
1235 
 
1236 
  def read(self, iprot):
1237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1239 
      return
1240 
    iprot.readStructBegin()
1241 
    while True:
1242 
      (fname, ftype, fid) = iprot.readFieldBegin()
1243 
      if ftype == TType.STOP:
1244 
        break
1245 
      if fid == 1:
1246 
        if ftype == TType.I64:
1247 
          self.customerId = iprot.readI64();
1248 
        else:
1249 
          iprot.skip(ftype)
1250 
      elif fid == 2:
1251 
        if ftype == TType.I64:
1252 
          self.from_date = iprot.readI64();
1253 
        else:
1254 
          iprot.skip(ftype)
1255 
      elif fid == 3:
1256 
        if ftype == TType.I64:
1257 
          self.to_date = iprot.readI64();
1258 
        else:
1259 
          iprot.skip(ftype)
1260 
      elif fid == 4:
1261 
        if ftype == TType.I32:
1262 
          self.status = iprot.readI32();
1263 
        else:
1264 
          iprot.skip(ftype)
1265 
      else:
1266 
        iprot.skip(ftype)
1267 
      iprot.readFieldEnd()
1268 
    iprot.readStructEnd()
1269 
 
1270 
  def write(self, oprot):
1271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1273 
      return
1274 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
1275 
    if self.customerId != None:
1276 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
1277 
      oprot.writeI64(self.customerId)
1278 
      oprot.writeFieldEnd()
1279 
    if self.from_date != None:
1280 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
1281 
      oprot.writeI64(self.from_date)
1282 
      oprot.writeFieldEnd()
1283 
    if self.to_date != None:
1284 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
1285 
      oprot.writeI64(self.to_date)
1286 
      oprot.writeFieldEnd()
1287 
    if self.status != None:
1288 
      oprot.writeFieldBegin('status', TType.I32, 4)
1289 
      oprot.writeI32(self.status)
1290 
      oprot.writeFieldEnd()
1291 
    oprot.writeFieldStop()
1292 
    oprot.writeStructEnd()
1293 
 
1294 
  def __repr__(self):
1295 
    L = ['%s=%r' % (key, value)
1296 
      for key, value in self.__dict__.iteritems()]
1297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1298 
 
1299 
  def __eq__(self, other):
1300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1301 
 
1302 
  def __ne__(self, other):
1303 
    return not (self == other)
1304 
 
1305 
class getTransactionsForCustomer_result:
1306 
  """
1307 
  Attributes:
1308 
   - success
1309 
   - ex
1310 
  """
1311 
 
1312 
  thrift_spec = (
1313 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
1314 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1315 
  )
1316 
 
1317 
  def __init__(self, success=None, ex=None,):
1318 
    self.success = success
1319 
    self.ex = ex
1320 
 
1321 
  def read(self, iprot):
1322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1324 
      return
1325 
    iprot.readStructBegin()
1326 
    while True:
1327 
      (fname, ftype, fid) = iprot.readFieldBegin()
1328 
      if ftype == TType.STOP:
1329 
        break
1330 
      if fid == 0:
1331 
        if ftype == TType.LIST:
1332 
          self.success = []
483 rajveer 1333 
          (_etype26, _size23) = iprot.readListBegin()
1334 
          for _i27 in xrange(_size23):
1335 
            _elem28 = Transaction()
1336 
            _elem28.read(iprot)
1337 
            self.success.append(_elem28)
94 ashish 1338 
          iprot.readListEnd()
1339 
        else:
1340 
          iprot.skip(ftype)
1341 
      elif fid == 1:
1342 
        if ftype == TType.STRUCT:
1343 
          self.ex = TransactionServiceException()
1344 
          self.ex.read(iprot)
1345 
        else:
1346 
          iprot.skip(ftype)
1347 
      else:
1348 
        iprot.skip(ftype)
1349 
      iprot.readFieldEnd()
1350 
    iprot.readStructEnd()
1351 
 
1352 
  def write(self, oprot):
1353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1355 
      return
1356 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
1357 
    if self.success != None:
1358 
      oprot.writeFieldBegin('success', TType.LIST, 0)
1359 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
483 rajveer 1360 
      for iter29 in self.success:
1361 
        iter29.write(oprot)
94 ashish 1362 
      oprot.writeListEnd()
1363 
      oprot.writeFieldEnd()
1364 
    if self.ex != None:
1365 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
1366 
      self.ex.write(oprot)
1367 
      oprot.writeFieldEnd()
1368 
    oprot.writeFieldStop()
1369 
    oprot.writeStructEnd()
1370 
 
1371 
  def __repr__(self):
1372 
    L = ['%s=%r' % (key, value)
1373 
      for key, value in self.__dict__.iteritems()]
1374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1375 
 
1376 
  def __eq__(self, other):
1377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1378 
 
1379 
  def __ne__(self, other):
1380 
    return not (self == other)
1381 
 
132 ashish 1382 
class getTransactionsForShoppingCartId_args:
1383 
  """
1384 
  Attributes:
1385 
   - shoppingCartId
1386 
  """
1387 
 
1388 
  thrift_spec = (
1389 
    None, # 0
1390 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
1391 
  )
1392 
 
1393 
  def __init__(self, shoppingCartId=None,):
1394 
    self.shoppingCartId = shoppingCartId
1395 
 
1396 
  def read(self, iprot):
1397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1399 
      return
1400 
    iprot.readStructBegin()
1401 
    while True:
1402 
      (fname, ftype, fid) = iprot.readFieldBegin()
1403 
      if ftype == TType.STOP:
1404 
        break
1405 
      if fid == 1:
1406 
        if ftype == TType.I64:
1407 
          self.shoppingCartId = iprot.readI64();
1408 
        else:
1409 
          iprot.skip(ftype)
1410 
      else:
1411 
        iprot.skip(ftype)
1412 
      iprot.readFieldEnd()
1413 
    iprot.readStructEnd()
1414 
 
1415 
  def write(self, oprot):
1416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1418 
      return
1419 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
1420 
    if self.shoppingCartId != None:
1421 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
1422 
      oprot.writeI64(self.shoppingCartId)
1423 
      oprot.writeFieldEnd()
1424 
    oprot.writeFieldStop()
1425 
    oprot.writeStructEnd()
1426 
 
1427 
  def __repr__(self):
1428 
    L = ['%s=%r' % (key, value)
1429 
      for key, value in self.__dict__.iteritems()]
1430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1431 
 
1432 
  def __eq__(self, other):
1433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1434 
 
1435 
  def __ne__(self, other):
1436 
    return not (self == other)
1437 
 
1438 
class getTransactionsForShoppingCartId_result:
1439 
  """
1440 
  Attributes:
1441 
   - success
1442 
   - ex
1443 
  """
1444 
 
1445 
  thrift_spec = (
1446 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
1447 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1448 
  )
1449 
 
1450 
  def __init__(self, success=None, ex=None,):
1451 
    self.success = success
1452 
    self.ex = ex
1453 
 
1454 
  def read(self, iprot):
1455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1457 
      return
1458 
    iprot.readStructBegin()
1459 
    while True:
1460 
      (fname, ftype, fid) = iprot.readFieldBegin()
1461 
      if ftype == TType.STOP:
1462 
        break
1463 
      if fid == 0:
1464 
        if ftype == TType.LIST:
1465 
          self.success = []
483 rajveer 1466 
          (_etype33, _size30) = iprot.readListBegin()
1467 
          for _i34 in xrange(_size30):
1468 
            _elem35 = Transaction()
1469 
            _elem35.read(iprot)
1470 
            self.success.append(_elem35)
132 ashish 1471 
          iprot.readListEnd()
1472 
        else:
1473 
          iprot.skip(ftype)
1474 
      elif fid == 1:
1475 
        if ftype == TType.STRUCT:
1476 
          self.ex = TransactionServiceException()
1477 
          self.ex.read(iprot)
1478 
        else:
1479 
          iprot.skip(ftype)
1480 
      else:
1481 
        iprot.skip(ftype)
1482 
      iprot.readFieldEnd()
1483 
    iprot.readStructEnd()
1484 
 
1485 
  def write(self, oprot):
1486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1488 
      return
1489 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
1490 
    if self.success != None:
1491 
      oprot.writeFieldBegin('success', TType.LIST, 0)
1492 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
483 rajveer 1493 
      for iter36 in self.success:
1494 
        iter36.write(oprot)
132 ashish 1495 
      oprot.writeListEnd()
1496 
      oprot.writeFieldEnd()
1497 
    if self.ex != None:
1498 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
1499 
      self.ex.write(oprot)
1500 
      oprot.writeFieldEnd()
1501 
    oprot.writeFieldStop()
1502 
    oprot.writeStructEnd()
1503 
 
1504 
  def __repr__(self):
1505 
    L = ['%s=%r' % (key, value)
1506 
      for key, value in self.__dict__.iteritems()]
1507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1508 
 
1509 
  def __eq__(self, other):
1510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1511 
 
1512 
  def __ne__(self, other):
1513 
    return not (self == other)
1514 
 
94 ashish 1515 
class getTransactionStatus_args:
1516 
  """
1517 
  Attributes:
1518 
   - transactionId
1519 
  """
1520 
 
1521 
  thrift_spec = (
1522 
    None, # 0
1523 
    (1, TType.I64, 'transactionId', None, None, ), # 1
1524 
  )
1525 
 
1526 
  def __init__(self, transactionId=None,):
1527 
    self.transactionId = transactionId
1528 
 
1529 
  def read(self, iprot):
1530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1532 
      return
1533 
    iprot.readStructBegin()
1534 
    while True:
1535 
      (fname, ftype, fid) = iprot.readFieldBegin()
1536 
      if ftype == TType.STOP:
1537 
        break
1538 
      if fid == 1:
1539 
        if ftype == TType.I64:
1540 
          self.transactionId = iprot.readI64();
1541 
        else:
1542 
          iprot.skip(ftype)
1543 
      else:
1544 
        iprot.skip(ftype)
1545 
      iprot.readFieldEnd()
1546 
    iprot.readStructEnd()
1547 
 
1548 
  def write(self, oprot):
1549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1551 
      return
1552 
    oprot.writeStructBegin('getTransactionStatus_args')
1553 
    if self.transactionId != None:
1554 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
1555 
      oprot.writeI64(self.transactionId)
1556 
      oprot.writeFieldEnd()
1557 
    oprot.writeFieldStop()
1558 
    oprot.writeStructEnd()
1559 
 
1560 
  def __repr__(self):
1561 
    L = ['%s=%r' % (key, value)
1562 
      for key, value in self.__dict__.iteritems()]
1563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1564 
 
1565 
  def __eq__(self, other):
1566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1567 
 
1568 
  def __ne__(self, other):
1569 
    return not (self == other)
1570 
 
1571 
class getTransactionStatus_result:
1572 
  """
1573 
  Attributes:
1574 
   - success
1575 
   - ex
1576 
  """
1577 
 
1578 
  thrift_spec = (
1579 
    (0, TType.I32, 'success', None, None, ), # 0
1580 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1581 
  )
1582 
 
1583 
  def __init__(self, success=None, ex=None,):
1584 
    self.success = success
1585 
    self.ex = ex
1586 
 
1587 
  def read(self, iprot):
1588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1590 
      return
1591 
    iprot.readStructBegin()
1592 
    while True:
1593 
      (fname, ftype, fid) = iprot.readFieldBegin()
1594 
      if ftype == TType.STOP:
1595 
        break
1596 
      if fid == 0:
1597 
        if ftype == TType.I32:
1598 
          self.success = iprot.readI32();
1599 
        else:
1600 
          iprot.skip(ftype)
1601 
      elif fid == 1:
1602 
        if ftype == TType.STRUCT:
1603 
          self.ex = TransactionServiceException()
1604 
          self.ex.read(iprot)
1605 
        else:
1606 
          iprot.skip(ftype)
1607 
      else:
1608 
        iprot.skip(ftype)
1609 
      iprot.readFieldEnd()
1610 
    iprot.readStructEnd()
1611 
 
1612 
  def write(self, oprot):
1613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1615 
      return
1616 
    oprot.writeStructBegin('getTransactionStatus_result')
1617 
    if self.success != None:
1618 
      oprot.writeFieldBegin('success', TType.I32, 0)
1619 
      oprot.writeI32(self.success)
1620 
      oprot.writeFieldEnd()
1621 
    if self.ex != None:
1622 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
1623 
      self.ex.write(oprot)
1624 
      oprot.writeFieldEnd()
1625 
    oprot.writeFieldStop()
1626 
    oprot.writeStructEnd()
1627 
 
1628 
  def __repr__(self):
1629 
    L = ['%s=%r' % (key, value)
1630 
      for key, value in self.__dict__.iteritems()]
1631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1632 
 
1633 
  def __eq__(self, other):
1634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1635 
 
1636 
  def __ne__(self, other):
1637 
    return not (self == other)
1638 
 
1639 
class changeTransactionStatus_args:
1640 
  """
1641 
  Attributes:
1642 
   - transactionId
1643 
   - status
1644 
   - description
1645 
  """
1646 
 
1647 
  thrift_spec = (
1648 
    None, # 0
1649 
    (1, TType.I64, 'transactionId', None, None, ), # 1
1650 
    (2, TType.I32, 'status', None, None, ), # 2
1651 
    (3, TType.STRING, 'description', None, None, ), # 3
1652 
  )
1653 
 
1654 
  def __init__(self, transactionId=None, status=None, description=None,):
1655 
    self.transactionId = transactionId
1656 
    self.status = status
1657 
    self.description = description
1658 
 
1659 
  def read(self, iprot):
1660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1662 
      return
1663 
    iprot.readStructBegin()
1664 
    while True:
1665 
      (fname, ftype, fid) = iprot.readFieldBegin()
1666 
      if ftype == TType.STOP:
1667 
        break
1668 
      if fid == 1:
1669 
        if ftype == TType.I64:
1670 
          self.transactionId = iprot.readI64();
1671 
        else:
1672 
          iprot.skip(ftype)
1673 
      elif fid == 2:
1674 
        if ftype == TType.I32:
1675 
          self.status = iprot.readI32();
1676 
        else:
1677 
          iprot.skip(ftype)
1678 
      elif fid == 3:
1679 
        if ftype == TType.STRING:
1680 
          self.description = iprot.readString();
1681 
        else:
1682 
          iprot.skip(ftype)
1683 
      else:
1684 
        iprot.skip(ftype)
1685 
      iprot.readFieldEnd()
1686 
    iprot.readStructEnd()
1687 
 
1688 
  def write(self, oprot):
1689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1691 
      return
1692 
    oprot.writeStructBegin('changeTransactionStatus_args')
1693 
    if self.transactionId != None:
1694 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
1695 
      oprot.writeI64(self.transactionId)
1696 
      oprot.writeFieldEnd()
1697 
    if self.status != None:
1698 
      oprot.writeFieldBegin('status', TType.I32, 2)
1699 
      oprot.writeI32(self.status)
1700 
      oprot.writeFieldEnd()
1701 
    if self.description != None:
1702 
      oprot.writeFieldBegin('description', TType.STRING, 3)
1703 
      oprot.writeString(self.description)
1704 
      oprot.writeFieldEnd()
1705 
    oprot.writeFieldStop()
1706 
    oprot.writeStructEnd()
1707 
 
1708 
  def __repr__(self):
1709 
    L = ['%s=%r' % (key, value)
1710 
      for key, value in self.__dict__.iteritems()]
1711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1712 
 
1713 
  def __eq__(self, other):
1714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1715 
 
1716 
  def __ne__(self, other):
1717 
    return not (self == other)
1718 
 
1719 
class changeTransactionStatus_result:
1720 
  """
1721 
  Attributes:
1722 
   - success
1723 
   - ex
1724 
  """
1725 
 
1726 
  thrift_spec = (
1727 
    (0, TType.BOOL, 'success', None, None, ), # 0
1728 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1729 
  )
1730 
 
1731 
  def __init__(self, success=None, ex=None,):
1732 
    self.success = success
1733 
    self.ex = ex
1734 
 
1735 
  def read(self, iprot):
1736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1738 
      return
1739 
    iprot.readStructBegin()
1740 
    while True:
1741 
      (fname, ftype, fid) = iprot.readFieldBegin()
1742 
      if ftype == TType.STOP:
1743 
        break
1744 
      if fid == 0:
1745 
        if ftype == TType.BOOL:
1746 
          self.success = iprot.readBool();
1747 
        else:
1748 
          iprot.skip(ftype)
1749 
      elif fid == 1:
1750 
        if ftype == TType.STRUCT:
1751 
          self.ex = TransactionServiceException()
1752 
          self.ex.read(iprot)
1753 
        else:
1754 
          iprot.skip(ftype)
1755 
      else:
1756 
        iprot.skip(ftype)
1757 
      iprot.readFieldEnd()
1758 
    iprot.readStructEnd()
1759 
 
1760 
  def write(self, oprot):
1761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1763 
      return
1764 
    oprot.writeStructBegin('changeTransactionStatus_result')
1765 
    if self.success != None:
1766 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
1767 
      oprot.writeBool(self.success)
1768 
      oprot.writeFieldEnd()
1769 
    if self.ex != None:
1770 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
1771 
      self.ex.write(oprot)
1772 
      oprot.writeFieldEnd()
1773 
    oprot.writeFieldStop()
1774 
    oprot.writeStructEnd()
1775 
 
1776 
  def __repr__(self):
1777 
    L = ['%s=%r' % (key, value)
1778 
      for key, value in self.__dict__.iteritems()]
1779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1780 
 
1781 
  def __eq__(self, other):
1782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1783 
 
1784 
  def __ne__(self, other):
1785 
    return not (self == other)
1786 
 
483 rajveer 1787 
class getAllOrders_args:
94 ashish 1788 
  """
1789 
  Attributes:
483 rajveer 1790 
   - status
1791 
   - from_date
1792 
   - to_date
1793 
   - warehouse_id
94 ashish 1794 
  """
1795 
 
1796 
  thrift_spec = (
1797 
    None, # 0
483 rajveer 1798 
    (1, TType.I32, 'status', None, None, ), # 1
1799 
    (2, TType.I64, 'from_date', None, None, ), # 2
1800 
    (3, TType.I64, 'to_date', None, None, ), # 3
1801 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 1802 
  )
1803 
 
483 rajveer 1804 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
1805 
    self.status = status
1806 
    self.from_date = from_date
1807 
    self.to_date = to_date
1808 
    self.warehouse_id = warehouse_id
94 ashish 1809 
 
1810 
  def read(self, iprot):
1811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1813 
      return
1814 
    iprot.readStructBegin()
1815 
    while True:
1816 
      (fname, ftype, fid) = iprot.readFieldBegin()
1817 
      if ftype == TType.STOP:
1818 
        break
1819 
      if fid == 1:
483 rajveer 1820 
        if ftype == TType.I32:
1821 
          self.status = iprot.readI32();
94 ashish 1822 
        else:
1823 
          iprot.skip(ftype)
483 rajveer 1824 
      elif fid == 2:
1825 
        if ftype == TType.I64:
1826 
          self.from_date = iprot.readI64();
94 ashish 1827 
        else:
1828 
          iprot.skip(ftype)
483 rajveer 1829 
      elif fid == 3:
1830 
        if ftype == TType.I64:
1831 
          self.to_date = iprot.readI64();
94 ashish 1832 
        else:
1833 
          iprot.skip(ftype)
483 rajveer 1834 
      elif fid == 4:
94 ashish 1835 
        if ftype == TType.I64:
483 rajveer 1836 
          self.warehouse_id = iprot.readI64();
94 ashish 1837 
        else:
1838 
          iprot.skip(ftype)
1839 
      else:
1840 
        iprot.skip(ftype)
1841 
      iprot.readFieldEnd()
1842 
    iprot.readStructEnd()
1843 
 
1844 
  def write(self, oprot):
1845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1847 
      return
483 rajveer 1848 
    oprot.writeStructBegin('getAllOrders_args')
1849 
    if self.status != None:
1850 
      oprot.writeFieldBegin('status', TType.I32, 1)
1851 
      oprot.writeI32(self.status)
94 ashish 1852 
      oprot.writeFieldEnd()
483 rajveer 1853 
    if self.from_date != None:
1854 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
1855 
      oprot.writeI64(self.from_date)
94 ashish 1856 
      oprot.writeFieldEnd()
483 rajveer 1857 
    if self.to_date != None:
1858 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
1859 
      oprot.writeI64(self.to_date)
94 ashish 1860 
      oprot.writeFieldEnd()
483 rajveer 1861 
    if self.warehouse_id != None:
1862 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
1863 
      oprot.writeI64(self.warehouse_id)
94 ashish 1864 
      oprot.writeFieldEnd()
1865 
    oprot.writeFieldStop()
1866 
    oprot.writeStructEnd()
1867 
 
1868 
  def __repr__(self):
1869 
    L = ['%s=%r' % (key, value)
1870 
      for key, value in self.__dict__.iteritems()]
1871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1872 
 
1873 
  def __eq__(self, other):
1874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1875 
 
1876 
  def __ne__(self, other):
1877 
    return not (self == other)
1878 
 
483 rajveer 1879 
class getAllOrders_result:
94 ashish 1880 
  """
1881 
  Attributes:
1882 
   - success
1883 
   - ex
1884 
  """
1885 
 
1886 
  thrift_spec = (
483 rajveer 1887 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 1888 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1889 
  )
1890 
 
1891 
  def __init__(self, success=None, ex=None,):
1892 
    self.success = success
1893 
    self.ex = ex
1894 
 
1895 
  def read(self, iprot):
1896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1898 
      return
1899 
    iprot.readStructBegin()
1900 
    while True:
1901 
      (fname, ftype, fid) = iprot.readFieldBegin()
1902 
      if ftype == TType.STOP:
1903 
        break
1904 
      if fid == 0:
483 rajveer 1905 
        if ftype == TType.LIST:
1906 
          self.success = []
1907 
          (_etype40, _size37) = iprot.readListBegin()
1908 
          for _i41 in xrange(_size37):
1909 
            _elem42 = Order()
1910 
            _elem42.read(iprot)
1911 
            self.success.append(_elem42)
1912 
          iprot.readListEnd()
94 ashish 1913 
        else:
1914 
          iprot.skip(ftype)
1915 
      elif fid == 1:
1916 
        if ftype == TType.STRUCT:
1917 
          self.ex = TransactionServiceException()
1918 
          self.ex.read(iprot)
1919 
        else:
1920 
          iprot.skip(ftype)
1921 
      else:
1922 
        iprot.skip(ftype)
1923 
      iprot.readFieldEnd()
1924 
    iprot.readStructEnd()
1925 
 
1926 
  def write(self, oprot):
1927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1929 
      return
483 rajveer 1930 
    oprot.writeStructBegin('getAllOrders_result')
94 ashish 1931 
    if self.success != None:
483 rajveer 1932 
      oprot.writeFieldBegin('success', TType.LIST, 0)
1933 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1934 
      for iter43 in self.success:
1935 
        iter43.write(oprot)
1936 
      oprot.writeListEnd()
94 ashish 1937 
      oprot.writeFieldEnd()
1938 
    if self.ex != None:
1939 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
1940 
      self.ex.write(oprot)
1941 
      oprot.writeFieldEnd()
1942 
    oprot.writeFieldStop()
1943 
    oprot.writeStructEnd()
1944 
 
1945 
  def __repr__(self):
1946 
    L = ['%s=%r' % (key, value)
1947 
      for key, value in self.__dict__.iteritems()]
1948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1949 
 
1950 
  def __eq__(self, other):
1951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1952 
 
1953 
  def __ne__(self, other):
1954 
    return not (self == other)
1955 
 
483 rajveer 1956 
class changeOrderStatus_args:
94 ashish 1957 
  """
1958 
  Attributes:
483 rajveer 1959 
   - orderId
1960 
   - status
1961 
   - description
94 ashish 1962 
  """
1963 
 
1964 
  thrift_spec = (
1965 
    None, # 0
483 rajveer 1966 
    (1, TType.I64, 'orderId', None, None, ), # 1
1967 
    (2, TType.I32, 'status', None, None, ), # 2
1968 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 1969 
  )
1970 
 
483 rajveer 1971 
  def __init__(self, orderId=None, status=None, description=None,):
1972 
    self.orderId = orderId
1973 
    self.status = status
1974 
    self.description = description
94 ashish 1975 
 
1976 
  def read(self, iprot):
1977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1979 
      return
1980 
    iprot.readStructBegin()
1981 
    while True:
1982 
      (fname, ftype, fid) = iprot.readFieldBegin()
1983 
      if ftype == TType.STOP:
1984 
        break
1985 
      if fid == 1:
1986 
        if ftype == TType.I64:
483 rajveer 1987 
          self.orderId = iprot.readI64();
94 ashish 1988 
        else:
1989 
          iprot.skip(ftype)
1990 
      elif fid == 2:
483 rajveer 1991 
        if ftype == TType.I32:
1992 
          self.status = iprot.readI32();
94 ashish 1993 
        else:
1994 
          iprot.skip(ftype)
483 rajveer 1995 
      elif fid == 3:
1996 
        if ftype == TType.STRING:
1997 
          self.description = iprot.readString();
1998 
        else:
1999 
          iprot.skip(ftype)
94 ashish 2000 
      else:
2001 
        iprot.skip(ftype)
2002 
      iprot.readFieldEnd()
2003 
    iprot.readStructEnd()
2004 
 
2005 
  def write(self, oprot):
2006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2008 
      return
483 rajveer 2009 
    oprot.writeStructBegin('changeOrderStatus_args')
2010 
    if self.orderId != None:
2011 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
2012 
      oprot.writeI64(self.orderId)
94 ashish 2013 
      oprot.writeFieldEnd()
483 rajveer 2014 
    if self.status != None:
2015 
      oprot.writeFieldBegin('status', TType.I32, 2)
2016 
      oprot.writeI32(self.status)
94 ashish 2017 
      oprot.writeFieldEnd()
483 rajveer 2018 
    if self.description != None:
2019 
      oprot.writeFieldBegin('description', TType.STRING, 3)
2020 
      oprot.writeString(self.description)
2021 
      oprot.writeFieldEnd()
94 ashish 2022 
    oprot.writeFieldStop()
2023 
    oprot.writeStructEnd()
2024 
 
2025 
  def __repr__(self):
2026 
    L = ['%s=%r' % (key, value)
2027 
      for key, value in self.__dict__.iteritems()]
2028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2029 
 
2030 
  def __eq__(self, other):
2031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2032 
 
2033 
  def __ne__(self, other):
2034 
    return not (self == other)
2035 
 
483 rajveer 2036 
class changeOrderStatus_result:
94 ashish 2037 
  """
2038 
  Attributes:
2039 
   - success
2040 
   - ex
2041 
  """
2042 
 
2043 
  thrift_spec = (
2044 
    (0, TType.BOOL, 'success', None, None, ), # 0
2045 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2046 
  )
2047 
 
2048 
  def __init__(self, success=None, ex=None,):
2049 
    self.success = success
2050 
    self.ex = ex
2051 
 
2052 
  def read(self, iprot):
2053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2055 
      return
2056 
    iprot.readStructBegin()
2057 
    while True:
2058 
      (fname, ftype, fid) = iprot.readFieldBegin()
2059 
      if ftype == TType.STOP:
2060 
        break
2061 
      if fid == 0:
2062 
        if ftype == TType.BOOL:
2063 
          self.success = iprot.readBool();
2064 
        else:
2065 
          iprot.skip(ftype)
2066 
      elif fid == 1:
2067 
        if ftype == TType.STRUCT:
2068 
          self.ex = TransactionServiceException()
2069 
          self.ex.read(iprot)
2070 
        else:
2071 
          iprot.skip(ftype)
2072 
      else:
2073 
        iprot.skip(ftype)
2074 
      iprot.readFieldEnd()
2075 
    iprot.readStructEnd()
2076 
 
2077 
  def write(self, oprot):
2078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2080 
      return
483 rajveer 2081 
    oprot.writeStructBegin('changeOrderStatus_result')
94 ashish 2082 
    if self.success != None:
2083 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2084 
      oprot.writeBool(self.success)
2085 
      oprot.writeFieldEnd()
2086 
    if self.ex != None:
2087 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2088 
      self.ex.write(oprot)
2089 
      oprot.writeFieldEnd()
2090 
    oprot.writeFieldStop()
2091 
    oprot.writeStructEnd()
2092 
 
2093 
  def __repr__(self):
2094 
    L = ['%s=%r' % (key, value)
2095 
      for key, value in self.__dict__.iteritems()]
2096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2097 
 
2098 
  def __eq__(self, other):
2099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2100 
 
2101 
  def __ne__(self, other):
2102 
    return not (self == other)
2103 
 
494 rajveer 2104 
class addBillingDetails_args:
2105 
  """
2106 
  Attributes:
2107 
   - orderId
2108 
   - invoice_number
642 chandransh 2109 
   - jacket_number
494 rajveer 2110 
   - billed_by
2111 
  """
2112 
 
2113 
  thrift_spec = (
2114 
    None, # 0
2115 
    (1, TType.I64, 'orderId', None, None, ), # 1
2116 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
642 chandransh 2117 
    (3, TType.I64, 'jacket_number', None, None, ), # 3
2118 
    (4, TType.STRING, 'billed_by', None, None, ), # 4
494 rajveer 2119 
  )
2120 
 
642 chandransh 2121 
  def __init__(self, orderId=None, invoice_number=None, jacket_number=None, billed_by=None,):
494 rajveer 2122 
    self.orderId = orderId
2123 
    self.invoice_number = invoice_number
642 chandransh 2124 
    self.jacket_number = jacket_number
494 rajveer 2125 
    self.billed_by = billed_by
2126 
 
2127 
  def read(self, iprot):
2128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2130 
      return
2131 
    iprot.readStructBegin()
2132 
    while True:
2133 
      (fname, ftype, fid) = iprot.readFieldBegin()
2134 
      if ftype == TType.STOP:
2135 
        break
2136 
      if fid == 1:
2137 
        if ftype == TType.I64:
2138 
          self.orderId = iprot.readI64();
2139 
        else:
2140 
          iprot.skip(ftype)
2141 
      elif fid == 2:
2142 
        if ftype == TType.STRING:
2143 
          self.invoice_number = iprot.readString();
2144 
        else:
2145 
          iprot.skip(ftype)
2146 
      elif fid == 3:
642 chandransh 2147 
        if ftype == TType.I64:
2148 
          self.jacket_number = iprot.readI64();
2149 
        else:
2150 
          iprot.skip(ftype)
2151 
      elif fid == 4:
494 rajveer 2152 
        if ftype == TType.STRING:
2153 
          self.billed_by = iprot.readString();
2154 
        else:
2155 
          iprot.skip(ftype)
2156 
      else:
2157 
        iprot.skip(ftype)
2158 
      iprot.readFieldEnd()
2159 
    iprot.readStructEnd()
2160 
 
2161 
  def write(self, oprot):
2162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2164 
      return
2165 
    oprot.writeStructBegin('addBillingDetails_args')
2166 
    if self.orderId != None:
2167 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
2168 
      oprot.writeI64(self.orderId)
2169 
      oprot.writeFieldEnd()
2170 
    if self.invoice_number != None:
2171 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
2172 
      oprot.writeString(self.invoice_number)
2173 
      oprot.writeFieldEnd()
642 chandransh 2174 
    if self.jacket_number != None:
2175 
      oprot.writeFieldBegin('jacket_number', TType.I64, 3)
2176 
      oprot.writeI64(self.jacket_number)
2177 
      oprot.writeFieldEnd()
494 rajveer 2178 
    if self.billed_by != None:
642 chandransh 2179 
      oprot.writeFieldBegin('billed_by', TType.STRING, 4)
494 rajveer 2180 
      oprot.writeString(self.billed_by)
2181 
      oprot.writeFieldEnd()
2182 
    oprot.writeFieldStop()
2183 
    oprot.writeStructEnd()
2184 
 
2185 
  def __repr__(self):
2186 
    L = ['%s=%r' % (key, value)
2187 
      for key, value in self.__dict__.iteritems()]
2188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2189 
 
2190 
  def __eq__(self, other):
2191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2192 
 
2193 
  def __ne__(self, other):
2194 
    return not (self == other)
2195 
 
2196 
class addBillingDetails_result:
2197 
  """
2198 
  Attributes:
2199 
   - success
2200 
   - ex
2201 
  """
2202 
 
2203 
  thrift_spec = (
2204 
    (0, TType.BOOL, 'success', None, None, ), # 0
2205 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2206 
  )
2207 
 
2208 
  def __init__(self, success=None, ex=None,):
2209 
    self.success = success
2210 
    self.ex = ex
2211 
 
2212 
  def read(self, iprot):
2213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2215 
      return
2216 
    iprot.readStructBegin()
2217 
    while True:
2218 
      (fname, ftype, fid) = iprot.readFieldBegin()
2219 
      if ftype == TType.STOP:
2220 
        break
2221 
      if fid == 0:
2222 
        if ftype == TType.BOOL:
2223 
          self.success = iprot.readBool();
2224 
        else:
2225 
          iprot.skip(ftype)
2226 
      elif fid == 1:
2227 
        if ftype == TType.STRUCT:
2228 
          self.ex = TransactionServiceException()
2229 
          self.ex.read(iprot)
2230 
        else:
2231 
          iprot.skip(ftype)
2232 
      else:
2233 
        iprot.skip(ftype)
2234 
      iprot.readFieldEnd()
2235 
    iprot.readStructEnd()
2236 
 
2237 
  def write(self, oprot):
2238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2240 
      return
2241 
    oprot.writeStructBegin('addBillingDetails_result')
2242 
    if self.success != None:
2243 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2244 
      oprot.writeBool(self.success)
2245 
      oprot.writeFieldEnd()
2246 
    if self.ex != None:
2247 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2248 
      self.ex.write(oprot)
2249 
      oprot.writeFieldEnd()
2250 
    oprot.writeFieldStop()
2251 
    oprot.writeStructEnd()
2252 
 
2253 
  def __repr__(self):
2254 
    L = ['%s=%r' % (key, value)
2255 
      for key, value in self.__dict__.iteritems()]
2256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2257 
 
2258 
  def __eq__(self, other):
2259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2260 
 
2261 
  def __ne__(self, other):
2262 
    return not (self == other)
2263 
 
483 rajveer 2264 
class getOrdersForTransaction_args:
94 ashish 2265 
  """
2266 
  Attributes:
2267 
   - transactionId
2268 
  """
2269 
 
2270 
  thrift_spec = (
2271 
    None, # 0
2272 
    (1, TType.I64, 'transactionId', None, None, ), # 1
2273 
  )
2274 
 
483 rajveer 2275 
  def __init__(self, transactionId=None,):
94 ashish 2276 
    self.transactionId = transactionId
2277 
 
2278 
  def read(self, iprot):
2279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2281 
      return
2282 
    iprot.readStructBegin()
2283 
    while True:
2284 
      (fname, ftype, fid) = iprot.readFieldBegin()
2285 
      if ftype == TType.STOP:
2286 
        break
2287 
      if fid == 1:
2288 
        if ftype == TType.I64:
2289 
          self.transactionId = iprot.readI64();
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
483 rajveer 2301 
    oprot.writeStructBegin('getOrdersForTransaction_args')
94 ashish 2302 
    if self.transactionId != None:
2303 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
2304 
      oprot.writeI64(self.transactionId)
2305 
      oprot.writeFieldEnd()
2306 
    oprot.writeFieldStop()
2307 
    oprot.writeStructEnd()
2308 
 
2309 
  def __repr__(self):
2310 
    L = ['%s=%r' % (key, value)
2311 
      for key, value in self.__dict__.iteritems()]
2312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2313 
 
2314 
  def __eq__(self, other):
2315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2316 
 
2317 
  def __ne__(self, other):
2318 
    return not (self == other)
2319 
 
483 rajveer 2320 
class getOrdersForTransaction_result:
94 ashish 2321 
  """
2322 
  Attributes:
2323 
   - success
2324 
   - ex
2325 
  """
2326 
 
2327 
  thrift_spec = (
483 rajveer 2328 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 2329 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2330 
  )
2331 
 
2332 
  def __init__(self, success=None, ex=None,):
2333 
    self.success = success
2334 
    self.ex = ex
2335 
 
2336 
  def read(self, iprot):
2337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2339 
      return
2340 
    iprot.readStructBegin()
2341 
    while True:
2342 
      (fname, ftype, fid) = iprot.readFieldBegin()
2343 
      if ftype == TType.STOP:
2344 
        break
2345 
      if fid == 0:
483 rajveer 2346 
        if ftype == TType.LIST:
2347 
          self.success = []
2348 
          (_etype47, _size44) = iprot.readListBegin()
2349 
          for _i48 in xrange(_size44):
2350 
            _elem49 = Order()
2351 
            _elem49.read(iprot)
2352 
            self.success.append(_elem49)
2353 
          iprot.readListEnd()
94 ashish 2354 
        else:
2355 
          iprot.skip(ftype)
2356 
      elif fid == 1:
2357 
        if ftype == TType.STRUCT:
2358 
          self.ex = TransactionServiceException()
2359 
          self.ex.read(iprot)
2360 
        else:
2361 
          iprot.skip(ftype)
2362 
      else:
2363 
        iprot.skip(ftype)
2364 
      iprot.readFieldEnd()
2365 
    iprot.readStructEnd()
2366 
 
2367 
  def write(self, oprot):
2368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2370 
      return
483 rajveer 2371 
    oprot.writeStructBegin('getOrdersForTransaction_result')
94 ashish 2372 
    if self.success != None:
483 rajveer 2373 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2374 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2375 
      for iter50 in self.success:
2376 
        iter50.write(oprot)
2377 
      oprot.writeListEnd()
94 ashish 2378 
      oprot.writeFieldEnd()
2379 
    if self.ex != None:
2380 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2381 
      self.ex.write(oprot)
2382 
      oprot.writeFieldEnd()
2383 
    oprot.writeFieldStop()
2384 
    oprot.writeStructEnd()
2385 
 
2386 
  def __repr__(self):
2387 
    L = ['%s=%r' % (key, value)
2388 
      for key, value in self.__dict__.iteritems()]
2389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2390 
 
2391 
  def __eq__(self, other):
2392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2393 
 
2394 
  def __ne__(self, other):
2395 
    return not (self == other)
2396 
 
483 rajveer 2397 
class getOrdersForCustomer_args:
94 ashish 2398 
  """
2399 
  Attributes:
483 rajveer 2400 
   - customerId
2401 
   - from_date
2402 
   - to_date
2403 
   - status
94 ashish 2404 
  """
2405 
 
2406 
  thrift_spec = (
2407 
    None, # 0
483 rajveer 2408 
    (1, TType.I64, 'customerId', None, None, ), # 1
2409 
    (2, TType.I64, 'from_date', None, None, ), # 2
2410 
    (3, TType.I64, 'to_date', None, None, ), # 3
2411 
    (4, TType.I32, 'status', None, None, ), # 4
94 ashish 2412 
  )
2413 
 
483 rajveer 2414 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
2415 
    self.customerId = customerId
2416 
    self.from_date = from_date
2417 
    self.to_date = to_date
2418 
    self.status = status
94 ashish 2419 
 
2420 
  def read(self, iprot):
2421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2423 
      return
2424 
    iprot.readStructBegin()
2425 
    while True:
2426 
      (fname, ftype, fid) = iprot.readFieldBegin()
2427 
      if ftype == TType.STOP:
2428 
        break
2429 
      if fid == 1:
2430 
        if ftype == TType.I64:
483 rajveer 2431 
          self.customerId = iprot.readI64();
94 ashish 2432 
        else:
2433 
          iprot.skip(ftype)
2434 
      elif fid == 2:
2435 
        if ftype == TType.I64:
483 rajveer 2436 
          self.from_date = iprot.readI64();
94 ashish 2437 
        else:
2438 
          iprot.skip(ftype)
2439 
      elif fid == 3:
2440 
        if ftype == TType.I64:
483 rajveer 2441 
          self.to_date = iprot.readI64();
94 ashish 2442 
        else:
2443 
          iprot.skip(ftype)
483 rajveer 2444 
      elif fid == 4:
2445 
        if ftype == TType.I32:
2446 
          self.status = iprot.readI32();
2447 
        else:
2448 
          iprot.skip(ftype)
94 ashish 2449 
      else:
2450 
        iprot.skip(ftype)
2451 
      iprot.readFieldEnd()
2452 
    iprot.readStructEnd()
2453 
 
2454 
  def write(self, oprot):
2455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2457 
      return
483 rajveer 2458 
    oprot.writeStructBegin('getOrdersForCustomer_args')
2459 
    if self.customerId != None:
2460 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
2461 
      oprot.writeI64(self.customerId)
94 ashish 2462 
      oprot.writeFieldEnd()
483 rajveer 2463 
    if self.from_date != None:
2464 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
2465 
      oprot.writeI64(self.from_date)
94 ashish 2466 
      oprot.writeFieldEnd()
483 rajveer 2467 
    if self.to_date != None:
2468 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
2469 
      oprot.writeI64(self.to_date)
94 ashish 2470 
      oprot.writeFieldEnd()
483 rajveer 2471 
    if self.status != None:
2472 
      oprot.writeFieldBegin('status', TType.I32, 4)
2473 
      oprot.writeI32(self.status)
2474 
      oprot.writeFieldEnd()
94 ashish 2475 
    oprot.writeFieldStop()
2476 
    oprot.writeStructEnd()
2477 
 
2478 
  def __repr__(self):
2479 
    L = ['%s=%r' % (key, value)
2480 
      for key, value in self.__dict__.iteritems()]
2481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2482 
 
2483 
  def __eq__(self, other):
2484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2485 
 
2486 
  def __ne__(self, other):
2487 
    return not (self == other)
2488 
 
483 rajveer 2489 
class getOrdersForCustomer_result:
94 ashish 2490 
  """
2491 
  Attributes:
2492 
   - success
2493 
   - ex
2494 
  """
2495 
 
2496 
  thrift_spec = (
483 rajveer 2497 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 2498 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2499 
  )
2500 
 
2501 
  def __init__(self, success=None, ex=None,):
2502 
    self.success = success
2503 
    self.ex = ex
2504 
 
2505 
  def read(self, iprot):
2506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2508 
      return
2509 
    iprot.readStructBegin()
2510 
    while True:
2511 
      (fname, ftype, fid) = iprot.readFieldBegin()
2512 
      if ftype == TType.STOP:
2513 
        break
2514 
      if fid == 0:
483 rajveer 2515 
        if ftype == TType.LIST:
2516 
          self.success = []
2517 
          (_etype54, _size51) = iprot.readListBegin()
2518 
          for _i55 in xrange(_size51):
2519 
            _elem56 = Order()
2520 
            _elem56.read(iprot)
2521 
            self.success.append(_elem56)
2522 
          iprot.readListEnd()
94 ashish 2523 
        else:
2524 
          iprot.skip(ftype)
2525 
      elif fid == 1:
2526 
        if ftype == TType.STRUCT:
2527 
          self.ex = TransactionServiceException()
2528 
          self.ex.read(iprot)
2529 
        else:
2530 
          iprot.skip(ftype)
2531 
      else:
2532 
        iprot.skip(ftype)
2533 
      iprot.readFieldEnd()
2534 
    iprot.readStructEnd()
2535 
 
2536 
  def write(self, oprot):
2537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2539 
      return
483 rajveer 2540 
    oprot.writeStructBegin('getOrdersForCustomer_result')
94 ashish 2541 
    if self.success != None:
483 rajveer 2542 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2543 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2544 
      for iter57 in self.success:
2545 
        iter57.write(oprot)
2546 
      oprot.writeListEnd()
94 ashish 2547 
      oprot.writeFieldEnd()
2548 
    if self.ex != None:
2549 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2550 
      self.ex.write(oprot)
2551 
      oprot.writeFieldEnd()
2552 
    oprot.writeFieldStop()
2553 
    oprot.writeStructEnd()
2554 
 
2555 
  def __repr__(self):
2556 
    L = ['%s=%r' % (key, value)
2557 
      for key, value in self.__dict__.iteritems()]
2558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2559 
 
2560 
  def __eq__(self, other):
2561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2562 
 
2563 
  def __ne__(self, other):
2564 
    return not (self == other)
2565 
 
483 rajveer 2566 
class createOrder_args:
94 ashish 2567 
  """
2568 
  Attributes:
483 rajveer 2569 
   - order
94 ashish 2570 
  """
2571 
 
2572 
  thrift_spec = (
2573 
    None, # 0
483 rajveer 2574 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
94 ashish 2575 
  )
2576 
 
483 rajveer 2577 
  def __init__(self, order=None,):
2578 
    self.order = order
94 ashish 2579 
 
2580 
  def read(self, iprot):
2581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2583 
      return
2584 
    iprot.readStructBegin()
2585 
    while True:
2586 
      (fname, ftype, fid) = iprot.readFieldBegin()
2587 
      if ftype == TType.STOP:
2588 
        break
2589 
      if fid == 1:
483 rajveer 2590 
        if ftype == TType.STRUCT:
2591 
          self.order = Order()
2592 
          self.order.read(iprot)
94 ashish 2593 
        else:
2594 
          iprot.skip(ftype)
2595 
      else:
2596 
        iprot.skip(ftype)
2597 
      iprot.readFieldEnd()
2598 
    iprot.readStructEnd()
2599 
 
2600 
  def write(self, oprot):
2601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2603 
      return
483 rajveer 2604 
    oprot.writeStructBegin('createOrder_args')
2605 
    if self.order != None:
2606 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
2607 
      self.order.write(oprot)
94 ashish 2608 
      oprot.writeFieldEnd()
2609 
    oprot.writeFieldStop()
2610 
    oprot.writeStructEnd()
2611 
 
2612 
  def __repr__(self):
2613 
    L = ['%s=%r' % (key, value)
2614 
      for key, value in self.__dict__.iteritems()]
2615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2616 
 
2617 
  def __eq__(self, other):
2618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2619 
 
2620 
  def __ne__(self, other):
2621 
    return not (self == other)
2622 
 
483 rajveer 2623 
class createOrder_result:
94 ashish 2624 
  """
2625 
  Attributes:
2626 
   - success
2627 
   - ex
2628 
  """
2629 
 
2630 
  thrift_spec = (
483 rajveer 2631 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 2632 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2633 
  )
2634 
 
2635 
  def __init__(self, success=None, ex=None,):
2636 
    self.success = success
2637 
    self.ex = ex
2638 
 
2639 
  def read(self, iprot):
2640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2642 
      return
2643 
    iprot.readStructBegin()
2644 
    while True:
2645 
      (fname, ftype, fid) = iprot.readFieldBegin()
2646 
      if ftype == TType.STOP:
2647 
        break
2648 
      if fid == 0:
483 rajveer 2649 
        if ftype == TType.I64:
2650 
          self.success = iprot.readI64();
94 ashish 2651 
        else:
2652 
          iprot.skip(ftype)
2653 
      elif fid == 1:
2654 
        if ftype == TType.STRUCT:
2655 
          self.ex = TransactionServiceException()
2656 
          self.ex.read(iprot)
2657 
        else:
2658 
          iprot.skip(ftype)
2659 
      else:
2660 
        iprot.skip(ftype)
2661 
      iprot.readFieldEnd()
2662 
    iprot.readStructEnd()
2663 
 
2664 
  def write(self, oprot):
2665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2667 
      return
483 rajveer 2668 
    oprot.writeStructBegin('createOrder_result')
94 ashish 2669 
    if self.success != None:
483 rajveer 2670 
      oprot.writeFieldBegin('success', TType.I64, 0)
2671 
      oprot.writeI64(self.success)
94 ashish 2672 
      oprot.writeFieldEnd()
2673 
    if self.ex != None:
2674 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2675 
      self.ex.write(oprot)
2676 
      oprot.writeFieldEnd()
2677 
    oprot.writeFieldStop()
2678 
    oprot.writeStructEnd()
2679 
 
2680 
  def __repr__(self):
2681 
    L = ['%s=%r' % (key, value)
2682 
      for key, value in self.__dict__.iteritems()]
2683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2684 
 
2685 
  def __eq__(self, other):
2686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2687 
 
2688 
  def __ne__(self, other):
2689 
    return not (self == other)
2690 
 
483 rajveer 2691 
class getOrder_args:
94 ashish 2692 
  """
2693 
  Attributes:
483 rajveer 2694 
   - id
94 ashish 2695 
  """
2696 
 
2697 
  thrift_spec = (
2698 
    None, # 0
483 rajveer 2699 
    (1, TType.I64, 'id', None, None, ), # 1
94 ashish 2700 
  )
2701 
 
483 rajveer 2702 
  def __init__(self, id=None,):
2703 
    self.id = id
94 ashish 2704 
 
2705 
  def read(self, iprot):
2706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2708 
      return
2709 
    iprot.readStructBegin()
2710 
    while True:
2711 
      (fname, ftype, fid) = iprot.readFieldBegin()
2712 
      if ftype == TType.STOP:
2713 
        break
2714 
      if fid == 1:
2715 
        if ftype == TType.I64:
483 rajveer 2716 
          self.id = iprot.readI64();
94 ashish 2717 
        else:
2718 
          iprot.skip(ftype)
2719 
      else:
2720 
        iprot.skip(ftype)
2721 
      iprot.readFieldEnd()
2722 
    iprot.readStructEnd()
2723 
 
2724 
  def write(self, oprot):
2725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2727 
      return
483 rajveer 2728 
    oprot.writeStructBegin('getOrder_args')
2729 
    if self.id != None:
2730 
      oprot.writeFieldBegin('id', TType.I64, 1)
2731 
      oprot.writeI64(self.id)
94 ashish 2732 
      oprot.writeFieldEnd()
2733 
    oprot.writeFieldStop()
2734 
    oprot.writeStructEnd()
2735 
 
2736 
  def __repr__(self):
2737 
    L = ['%s=%r' % (key, value)
2738 
      for key, value in self.__dict__.iteritems()]
2739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2740 
 
2741 
  def __eq__(self, other):
2742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2743 
 
2744 
  def __ne__(self, other):
2745 
    return not (self == other)
2746 
 
483 rajveer 2747 
class getOrder_result:
94 ashish 2748 
  """
2749 
  Attributes:
2750 
   - success
2751 
   - ex
2752 
  """
2753 
 
2754 
  thrift_spec = (
483 rajveer 2755 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 2756 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2757 
  )
2758 
 
2759 
  def __init__(self, success=None, ex=None,):
2760 
    self.success = success
2761 
    self.ex = ex
2762 
 
2763 
  def read(self, iprot):
2764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2766 
      return
2767 
    iprot.readStructBegin()
2768 
    while True:
2769 
      (fname, ftype, fid) = iprot.readFieldBegin()
2770 
      if ftype == TType.STOP:
2771 
        break
2772 
      if fid == 0:
483 rajveer 2773 
        if ftype == TType.STRUCT:
2774 
          self.success = Order()
2775 
          self.success.read(iprot)
94 ashish 2776 
        else:
2777 
          iprot.skip(ftype)
2778 
      elif fid == 1:
2779 
        if ftype == TType.STRUCT:
2780 
          self.ex = TransactionServiceException()
2781 
          self.ex.read(iprot)
2782 
        else:
2783 
          iprot.skip(ftype)
2784 
      else:
2785 
        iprot.skip(ftype)
2786 
      iprot.readFieldEnd()
2787 
    iprot.readStructEnd()
2788 
 
2789 
  def write(self, oprot):
2790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2792 
      return
483 rajveer 2793 
    oprot.writeStructBegin('getOrder_result')
94 ashish 2794 
    if self.success != None:
483 rajveer 2795 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2796 
      self.success.write(oprot)
94 ashish 2797 
      oprot.writeFieldEnd()
2798 
    if self.ex != None:
2799 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2800 
      self.ex.write(oprot)
2801 
      oprot.writeFieldEnd()
2802 
    oprot.writeFieldStop()
2803 
    oprot.writeStructEnd()
2804 
 
2805 
  def __repr__(self):
2806 
    L = ['%s=%r' % (key, value)
2807 
      for key, value in self.__dict__.iteritems()]
2808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2809 
 
2810 
  def __eq__(self, other):
2811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2812 
 
2813 
  def __ne__(self, other):
2814 
    return not (self == other)
2815 
 
483 rajveer 2816 
class getLineItemsForOrder_args:
94 ashish 2817 
  """
2818 
  Attributes:
483 rajveer 2819 
   - orderId
94 ashish 2820 
  """
2821 
 
2822 
  thrift_spec = (
2823 
    None, # 0
483 rajveer 2824 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 2825 
  )
2826 
 
483 rajveer 2827 
  def __init__(self, orderId=None,):
2828 
    self.orderId = orderId
94 ashish 2829 
 
2830 
  def read(self, iprot):
2831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2833 
      return
2834 
    iprot.readStructBegin()
2835 
    while True:
2836 
      (fname, ftype, fid) = iprot.readFieldBegin()
2837 
      if ftype == TType.STOP:
2838 
        break
2839 
      if fid == 1:
2840 
        if ftype == TType.I64:
483 rajveer 2841 
          self.orderId = iprot.readI64();
94 ashish 2842 
        else:
2843 
          iprot.skip(ftype)
2844 
      else:
2845 
        iprot.skip(ftype)
2846 
      iprot.readFieldEnd()
2847 
    iprot.readStructEnd()
2848 
 
2849 
  def write(self, oprot):
2850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2852 
      return
483 rajveer 2853 
    oprot.writeStructBegin('getLineItemsForOrder_args')
2854 
    if self.orderId != None:
2855 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
2856 
      oprot.writeI64(self.orderId)
94 ashish 2857 
      oprot.writeFieldEnd()
2858 
    oprot.writeFieldStop()
2859 
    oprot.writeStructEnd()
2860 
 
2861 
  def __repr__(self):
2862 
    L = ['%s=%r' % (key, value)
2863 
      for key, value in self.__dict__.iteritems()]
2864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2865 
 
2866 
  def __eq__(self, other):
2867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2868 
 
2869 
  def __ne__(self, other):
2870 
    return not (self == other)
2871 
 
483 rajveer 2872 
class getLineItemsForOrder_result:
94 ashish 2873 
  """
2874 
  Attributes:
2875 
   - success
2876 
   - ex
2877 
  """
2878 
 
2879 
  thrift_spec = (
483 rajveer 2880 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 2881 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2882 
  )
2883 
 
2884 
  def __init__(self, success=None, ex=None,):
2885 
    self.success = success
2886 
    self.ex = ex
2887 
 
2888 
  def read(self, iprot):
2889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2891 
      return
2892 
    iprot.readStructBegin()
2893 
    while True:
2894 
      (fname, ftype, fid) = iprot.readFieldBegin()
2895 
      if ftype == TType.STOP:
2896 
        break
2897 
      if fid == 0:
483 rajveer 2898 
        if ftype == TType.LIST:
2899 
          self.success = []
2900 
          (_etype61, _size58) = iprot.readListBegin()
2901 
          for _i62 in xrange(_size58):
2902 
            _elem63 = LineItem()
2903 
            _elem63.read(iprot)
2904 
            self.success.append(_elem63)
2905 
          iprot.readListEnd()
94 ashish 2906 
        else:
2907 
          iprot.skip(ftype)
2908 
      elif fid == 1:
2909 
        if ftype == TType.STRUCT:
2910 
          self.ex = TransactionServiceException()
2911 
          self.ex.read(iprot)
2912 
        else:
2913 
          iprot.skip(ftype)
2914 
      else:
2915 
        iprot.skip(ftype)
2916 
      iprot.readFieldEnd()
2917 
    iprot.readStructEnd()
2918 
 
2919 
  def write(self, oprot):
2920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2922 
      return
483 rajveer 2923 
    oprot.writeStructBegin('getLineItemsForOrder_result')
94 ashish 2924 
    if self.success != None:
483 rajveer 2925 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2926 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2927 
      for iter64 in self.success:
2928 
        iter64.write(oprot)
2929 
      oprot.writeListEnd()
94 ashish 2930 
      oprot.writeFieldEnd()
2931 
    if self.ex != None:
2932 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2933 
      self.ex.write(oprot)
2934 
      oprot.writeFieldEnd()
2935 
    oprot.writeFieldStop()
2936 
    oprot.writeStructEnd()
2937 
 
2938 
  def __repr__(self):
2939 
    L = ['%s=%r' % (key, value)
2940 
      for key, value in self.__dict__.iteritems()]
2941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2942 
 
2943 
  def __eq__(self, other):
2944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2945 
 
2946 
  def __ne__(self, other):
2947 
    return not (self == other)
2948 
 
304 ashish 2949 
class getAlerts_args:
2950 
  """
2951 
  Attributes:
483 rajveer 2952 
   - orderId
304 ashish 2953 
   - valid
2954 
  """
94 ashish 2955 
 
304 ashish 2956 
  thrift_spec = (
2957 
    None, # 0
483 rajveer 2958 
    (1, TType.I64, 'orderId', None, None, ), # 1
304 ashish 2959 
    (2, TType.BOOL, 'valid', None, None, ), # 2
2960 
  )
2961 
 
483 rajveer 2962 
  def __init__(self, orderId=None, valid=None,):
2963 
    self.orderId = orderId
304 ashish 2964 
    self.valid = valid
2965 
 
2966 
  def read(self, iprot):
2967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2969 
      return
2970 
    iprot.readStructBegin()
2971 
    while True:
2972 
      (fname, ftype, fid) = iprot.readFieldBegin()
2973 
      if ftype == TType.STOP:
2974 
        break
2975 
      if fid == 1:
2976 
        if ftype == TType.I64:
483 rajveer 2977 
          self.orderId = iprot.readI64();
304 ashish 2978 
        else:
2979 
          iprot.skip(ftype)
2980 
      elif fid == 2:
2981 
        if ftype == TType.BOOL:
2982 
          self.valid = iprot.readBool();
2983 
        else:
2984 
          iprot.skip(ftype)
2985 
      else:
2986 
        iprot.skip(ftype)
2987 
      iprot.readFieldEnd()
2988 
    iprot.readStructEnd()
2989 
 
2990 
  def write(self, oprot):
2991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2993 
      return
2994 
    oprot.writeStructBegin('getAlerts_args')
483 rajveer 2995 
    if self.orderId != None:
2996 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
2997 
      oprot.writeI64(self.orderId)
304 ashish 2998 
      oprot.writeFieldEnd()
2999 
    if self.valid != None:
3000 
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
3001 
      oprot.writeBool(self.valid)
3002 
      oprot.writeFieldEnd()
3003 
    oprot.writeFieldStop()
3004 
    oprot.writeStructEnd()
3005 
 
3006 
  def __repr__(self):
3007 
    L = ['%s=%r' % (key, value)
3008 
      for key, value in self.__dict__.iteritems()]
3009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3010 
 
3011 
  def __eq__(self, other):
3012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3013 
 
3014 
  def __ne__(self, other):
3015 
    return not (self == other)
3016 
 
3017 
class getAlerts_result:
3018 
  """
3019 
  Attributes:
3020 
   - success
3021 
  """
3022 
 
3023 
  thrift_spec = (
3024 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
3025 
  )
3026 
 
3027 
  def __init__(self, success=None,):
3028 
    self.success = success
3029 
 
3030 
  def read(self, iprot):
3031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3033 
      return
3034 
    iprot.readStructBegin()
3035 
    while True:
3036 
      (fname, ftype, fid) = iprot.readFieldBegin()
3037 
      if ftype == TType.STOP:
3038 
        break
3039 
      if fid == 0:
3040 
        if ftype == TType.LIST:
3041 
          self.success = []
483 rajveer 3042 
          (_etype68, _size65) = iprot.readListBegin()
3043 
          for _i69 in xrange(_size65):
3044 
            _elem70 = Alert()
3045 
            _elem70.read(iprot)
3046 
            self.success.append(_elem70)
304 ashish 3047 
          iprot.readListEnd()
3048 
        else:
3049 
          iprot.skip(ftype)
3050 
      else:
3051 
        iprot.skip(ftype)
3052 
      iprot.readFieldEnd()
3053 
    iprot.readStructEnd()
3054 
 
3055 
  def write(self, oprot):
3056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3058 
      return
3059 
    oprot.writeStructBegin('getAlerts_result')
3060 
    if self.success != None:
3061 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3062 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
483 rajveer 3063 
      for iter71 in self.success:
3064 
        iter71.write(oprot)
304 ashish 3065 
      oprot.writeListEnd()
3066 
      oprot.writeFieldEnd()
3067 
    oprot.writeFieldStop()
3068 
    oprot.writeStructEnd()
3069 
 
3070 
  def __repr__(self):
3071 
    L = ['%s=%r' % (key, value)
3072 
      for key, value in self.__dict__.iteritems()]
3073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3074 
 
3075 
  def __eq__(self, other):
3076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3077 
 
3078 
  def __ne__(self, other):
3079 
    return not (self == other)
3080 
 
3081 
class setAlert_args:
3082 
  """
3083 
  Attributes:
483 rajveer 3084 
   - orderId
304 ashish 3085 
   - unset
3086 
   - type
3087 
   - comment
3088 
  """
3089 
 
3090 
  thrift_spec = (
3091 
    None, # 0
483 rajveer 3092 
    (1, TType.I64, 'orderId', None, None, ), # 1
304 ashish 3093 
    (2, TType.BOOL, 'unset', None, None, ), # 2
3094 
    (3, TType.I64, 'type', None, None, ), # 3
3095 
    (4, TType.STRING, 'comment', None, None, ), # 4
3096 
  )
3097 
 
483 rajveer 3098 
  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
3099 
    self.orderId = orderId
304 ashish 3100 
    self.unset = unset
3101 
    self.type = type
3102 
    self.comment = comment
3103 
 
3104 
  def read(self, iprot):
3105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3107 
      return
3108 
    iprot.readStructBegin()
3109 
    while True:
3110 
      (fname, ftype, fid) = iprot.readFieldBegin()
3111 
      if ftype == TType.STOP:
3112 
        break
3113 
      if fid == 1:
3114 
        if ftype == TType.I64:
483 rajveer 3115 
          self.orderId = iprot.readI64();
304 ashish 3116 
        else:
3117 
          iprot.skip(ftype)
3118 
      elif fid == 2:
3119 
        if ftype == TType.BOOL:
3120 
          self.unset = iprot.readBool();
3121 
        else:
3122 
          iprot.skip(ftype)
3123 
      elif fid == 3:
3124 
        if ftype == TType.I64:
3125 
          self.type = iprot.readI64();
3126 
        else:
3127 
          iprot.skip(ftype)
3128 
      elif fid == 4:
3129 
        if ftype == TType.STRING:
3130 
          self.comment = iprot.readString();
3131 
        else:
3132 
          iprot.skip(ftype)
3133 
      else:
3134 
        iprot.skip(ftype)
3135 
      iprot.readFieldEnd()
3136 
    iprot.readStructEnd()
3137 
 
3138 
  def write(self, oprot):
3139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3141 
      return
3142 
    oprot.writeStructBegin('setAlert_args')
483 rajveer 3143 
    if self.orderId != None:
3144 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
3145 
      oprot.writeI64(self.orderId)
304 ashish 3146 
      oprot.writeFieldEnd()
3147 
    if self.unset != None:
3148 
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
3149 
      oprot.writeBool(self.unset)
3150 
      oprot.writeFieldEnd()
3151 
    if self.type != None:
3152 
      oprot.writeFieldBegin('type', TType.I64, 3)
3153 
      oprot.writeI64(self.type)
3154 
      oprot.writeFieldEnd()
3155 
    if self.comment != None:
3156 
      oprot.writeFieldBegin('comment', TType.STRING, 4)
3157 
      oprot.writeString(self.comment)
3158 
      oprot.writeFieldEnd()
3159 
    oprot.writeFieldStop()
3160 
    oprot.writeStructEnd()
3161 
 
3162 
  def __repr__(self):
3163 
    L = ['%s=%r' % (key, value)
3164 
      for key, value in self.__dict__.iteritems()]
3165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3166 
 
3167 
  def __eq__(self, other):
3168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3169 
 
3170 
  def __ne__(self, other):
3171 
    return not (self == other)
3172 
 
3173 
class setAlert_result:
3174 
 
3175 
  thrift_spec = (
3176 
  )
3177 
 
3178 
  def read(self, iprot):
3179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3181 
      return
3182 
    iprot.readStructBegin()
3183 
    while True:
3184 
      (fname, ftype, fid) = iprot.readFieldBegin()
3185 
      if ftype == TType.STOP:
3186 
        break
3187 
      else:
3188 
        iprot.skip(ftype)
3189 
      iprot.readFieldEnd()
3190 
    iprot.readStructEnd()
3191 
 
3192 
  def write(self, oprot):
3193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3195 
      return
3196 
    oprot.writeStructBegin('setAlert_result')
3197 
    oprot.writeFieldStop()
3198 
    oprot.writeStructEnd()
3199 
 
3200 
  def __repr__(self):
3201 
    L = ['%s=%r' % (key, value)
3202 
      for key, value in self.__dict__.iteritems()]
3203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3204 
 
3205 
  def __eq__(self, other):
3206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3207 
 
3208 
  def __ne__(self, other):
3209 
    return not (self == other)
3210 
 
3211