Subversion Repositories SmartDukaan

Rev

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