Subversion Repositories SmartDukaan

Rev

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