Subversion Repositories SmartDukaan

Rev

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

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