Subversion Repositories SmartDukaan

Rev

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