Subversion Repositories SmartDukaan

Rev

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

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