Subversion Repositories SmartDukaan

Rev

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

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