Subversion Repositories SmartDukaan

Rev

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