Subversion Repositories SmartDukaan

Rev

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

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