Subversion Repositories SmartDukaan

Rev

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