Subversion Repositories SmartDukaan

Rev

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

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