Subversion Repositories SmartDukaan

Rev

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

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