Subversion Repositories SmartDukaan

Rev

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