Subversion Repositories SmartDukaan

Rev

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