Subversion Repositories SmartDukaan

Rev

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