class Beschluss(db.Model, ModelCore):
__tablename__ = 'beschluss'
dokument_text = db.Column(db.Unicode())
tenor = db.Column(db.Unicode())
seite = db.Column(db.Unicode())
position_id = db.Column(db.Integer, db.ForeignKey('position.id'))
def to_ref(self):
return {
'id': self.id,
'dokument_text': self.dokument_text,
'tenor': self.tenor,
'seite': self.seite,
'position': self.position.id
}
def to_dict(self):
data = self.to_ref()
data.update({
'dokument': self.dokument.to_ref(),
'position': self.position.to_ref(),
'created_at': self.created_at,
'updated_at': self.updated_at
})
return data
class Referenz(db.Model, ModelCore):
__tablename__ = 'referenz'
seiten = db.Column(db.Unicode())
text = db.Column(db.Unicode())
dokument_id = db.Column(db.Integer, db.ForeignKey('dokument.id'))
ablaeufe = db.relationship('Ablauf',
secondary=referenzen,
backref=db.backref('referenzen',
lazy='dynamic'))
def to_ref(self):
return {
'id': self.id,
'seiten': self.seiten,
'text': self.text,
'dokument': self.dokument.id
}
def to_dict(self):
data = self.to_ref()
data.update({
'dokument': self.dokument.to_ref(),
'ablaeufe': [a.to_ref() for a in self.ablaeufe],
'created_at': self.created_at,
'updated_at': self.updated_at
})
return data
class Beitrag(db.Model, ModelCore):
__tablename__ = 'beitrag'
seite = db.Column(db.Unicode())
art = db.Column(db.Unicode())
person_id = db.Column(db.Integer, db.ForeignKey('person.id'))
rolle_id = db.Column(db.Integer, db.ForeignKey('rolle.id'))
position_id = db.Column(db.Integer, db.ForeignKey('position.id'))
def to_ref(self):
return {
'id': self.id,
'seite': self.seite,
'art': self.art,
'position': self.position.id,
'rolle': self.rolle.id if self.rolle else None,
'person': self.person.id if self.person else None
}
def to_dict(self):
data = self.to_ref()
data.update({
'person': self.person.to_ref() if self.person else None,
'rolle': self.rolle.to_ref() if self.rolle else None,
'position': self.position.to_ref(),
'created_at': self.created_at,
'updated_at': self.updated_at
})
return data
class Abo(db.Model, ModelCore):
__tablename__ = 'abo'
query = db.Column(db.Unicode())
email = db.Column(db.Unicode())
offset = db.Column(db.DateTime, default=datetime.utcnow)
activation_code = db.Column(db.Unicode(), default=make_token)
include_activity = db.Column(db.Boolean)
include_speeches = db.Column(db.Boolean)
class Dokument(db.Model, ModelCore):
__tablename__ = 'dokument'
nummer = db.Column(db.Unicode())
hrsg = db.Column(db.Unicode())
typ = db.Column(db.Unicode())
link = db.Column(db.Unicode())
referenzen = db.relationship('Referenz',
backref='dokument',
lazy='dynamic')
positionen = db.relationship('Position',
backref='dokument',
lazy='dynamic')
beschluesse = db.relationship('Beschluss',
secondary=beschluesse_dokumente,
backref=db.backref('dokumente',
lazy='dynamic'))
@property
def typ_lang(self):
return {
'plpr': 'Plenarprotokoll',
'drs': 'Drucksache'
}.get(self.typ.lower(), 'Drucksache')
@property
def name(self):
return "%s (%s) %s" % (self.typ_lang, self.hrsg, self.nummer)
def to_ref(self):
return {
'id': self.id,
'name': self.name,
'nummer': self.nummer,
'hrsg': self.hrsg,
'typ': self.typ,
'link': self.link
}
def to_dict(self):
data = self.to_ref()
data.update({
'referenzen': [r.to_ref() for r in self.referenzen],
'positionen': [p.to_ref() for p in self.positionen],
'beschluesse': [b.to_ref() for b in self.beschluesse],
'created_at': self.created_at,
'updated_at': self.updated_at
})
return data
class Stimme(db.Model, ModelCore):
__tablename__ = 'stimme'
entscheidung = db.Column(db.Unicode())
person_id = db.Column(db.Integer,
db.ForeignKey('person.id'),
nullable=True)
abstimmung_id = db.Column(db.Integer,
db.ForeignKey('abstimmung.id'),
nullable=True)
def to_ref(self):
return {
'id': self.id,
'abstimmung': self.abstimmung.thema,
'person': self.person.to_ref(),
}
def to_dict(self):
data = self.to_ref()
data.update({
'abstimmung': self.abstimmung.to_ref(),
'person': self.person.to_ref(),
'created_at': self.created_at,
'updated_at': self.updated_at
})
return data
class Zuweisung(db.Model, ModelCore):
__tablename__ = 'zuweisung'
text = db.Column(db.Unicode())
federfuehrung = db.Column(db.Boolean())
gremium_id = db.Column(db.Integer, db.ForeignKey('gremium.id'))
position_id = db.Column(db.Integer, db.ForeignKey('position.id'))
def to_ref(self):
return {
'id': self.id,
'text': self.text,
'federfuehrung': self.federfuehrung,
'gremium': self.gremium.key if self.gremium else None,
'position': self.position.id if self.position else None
}
def to_dict(self):
data = self.to_ref()
data.update({
'gremium': self.gremium.to_ref(),
'position': self.position.to_ref(),
'created_at': self.created_at,
'updated_at': self.updated_at
})
return data
class Zitat(db.Model, ModelCore):
__tablename__ = 'zitat'
sequenz = db.Column(db.Integer())
sprecher = db.Column(db.Unicode())
text = db.Column(db.Unicode())
typ = db.Column(db.Unicode())
source_url = db.Column(db.Unicode())
person_id = db.Column(db.Integer,
db.ForeignKey('person.id'),
nullable=True)
sitzung_id = db.Column(db.Integer, db.ForeignKey('sitzung.id'))
debatte_id = db.Column(db.Integer, db.ForeignKey('debatte.id'))
rede_id = db.Column(db.Integer, db.ForeignKey('rede.id'))
def to_ref(self):
return {
'id': self.id,
'sequenz': self.sequenz,
'sprecher': self.sprecher,
'typ': self.typ,
}
def to_dict(self):
data = self.to_ref()
data.update({
'text': self.text,
'source_url': self.source_url,
'sitzung': self.sitzung.to_ref() if self.sitzung else None,
'person': self.person.to_ref() if self.person else None,
'debatte': self.debatte.to_ref() if self.debatte else None,
'rede': self.rede.to_ref() if self.rede else None,
'created_at': self.created_at,
'updated_at': self.updated_at
})
return data
def to_index(self):
data = super(Zitat, self).to_index()
data['debatte'] = self.debatte.to_dict()
data['sitzung'] = self.sitzung.to_dict()
data['rede'] = self.rede.to_dict()
return data
class Position(db.Model, ModelCore):
__tablename__ = 'position'
key = db.Column(db.Unicode())
zuordnung = db.Column(db.Unicode())
urheber = db.Column(db.Unicode())
fundstelle = db.Column(db.Unicode())
fundstelle_url = db.Column(db.Unicode())
date = db.Column(db.DateTime())
quelle = db.Column(db.Unicode())
typ = db.Column(db.Unicode())
ablauf_id = db.Column(db.Integer, db.ForeignKey('ablauf.id'))
dokument_id = db.Column(db.Integer, db.ForeignKey('dokument.id'))
debatte_id = db.Column(db.Integer,
db.ForeignKey('debatte.id'),
nullable=True)
zuweisungen = db.relationship('Zuweisung',
backref='position',
lazy='dynamic')
beschluesse = db.relationship('Beschluss',
backref='position',
lazy='dynamic')
beitraege = db.relationship('Beitrag', lazy='dynamic', backref='position')
def to_ref(self):
return {
'id': self.id,
'key': self.key,
'urheber': self.urheber,
'fundstelle': self.fundstelle,
'wahlperiode': self.ablauf.wahlperiode,
'ablauf': self.ablauf.key
}
def to_dict(self):
data = self.to_ref()
del data['wahlperiode']
data.update({
'zuordnung': self.zuordnung,
'fundstelle_url': self.fundstelle_url,
'date': self.date,
'quelle': self.quelle,
'typ': self.typ,
'ablauf': self.ablauf.to_ref(),
'debatte': self.debatte.to_ref() if self.debatte else None,
'dokument': self.dokument.to_ref() if self.dokument else None,
'zuweisungen': [z.to_ref() for z in self.zuweisungen],
'beschluesse': [b.to_ref() for b in self.beschluesse],
'beitraege': [b.to_dict() for b in self.beitraege],
'created_at': self.created_at,
'updated_at': self.updated_at
})
return data
class Debatte(db.Model, ModelCore):
__tablename__ = 'debatte'
tops = db.Column(db.Unicode())
nummer = db.Column(db.Integer())
titel = db.Column(db.Unicode())
text = db.Column(db.Unicode())
sitzung_id = db.Column(db.Integer, db.ForeignKey('sitzung.id'))
zitate = db.relationship('Zitat',
backref='debatte',
lazy='dynamic',
order_by='Zitat.sequenz.asc()')
reden = db.relationship('Rede',
backref='debatte',
lazy='dynamic',
order_by='Rede.webtv_id.asc()')
positionen = db.relationship('Position', backref='debatte', lazy='dynamic')
def to_ref(self):
return {'id': self.id, 'nummer': self.nummer, 'titel': self.titel}
def to_dict(self):
data = self.to_ref()
data.update({
'sitzung': self.sitzung.to_ref() if self.sitzung else None,
'text': self.text,
'positionen': [p.to_ref() for p in self.positionen],
'created_at': self.created_at,
'updated_at': self.updated_at
})
return data
def to_index(self):
data = super(Debatte, self).to_index()
data['sitzung'] = self.sitzung.to_dict()
return data
class Schlagwort(db.Model):
__tablename__ = 'schlagwort'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode())
class Ablauf(db.Model, ModelCore):
__tablename__ = 'ablauf'
key = db.Column(db.Unicode())
source_url = db.Column(db.Unicode())
wahlperiode = db.Column(db.Unicode())
typ = db.Column(db.Unicode())
klasse = db.Column(db.Unicode())
titel = db.Column(db.Unicode())
initiative = db.Column(db.Unicode())
stand = db.Column(db.Unicode())
signatur = db.Column(db.Unicode())
gesta_id = db.Column(db.Unicode())
eu_dok_nr = db.Column(db.Unicode())
eur_lex_url = db.Column(db.Unicode())
eur_lex_pdf = db.Column(db.Unicode())
consilium_url = db.Column(db.Unicode())
abstrakt = db.Column(db.Unicode())
zustimmungsbeduerftig = db.Column(db.Unicode())
sachgebiet = db.Column(db.Unicode())
abgeschlossen = db.Column(db.Boolean())
schlagworte = db.relationship('Schlagwort',
secondary=schlagworte,
backref=db.backref('ablaeufe',
lazy='dynamic'))
positionen = db.relationship('Position',
backref='ablauf',
lazy='dynamic',
order_by='Position.date.desc()')
@property
def latest(self):
dates = [p.date for p in self.positionen if p.date]
if not len(dates):
return datetime.utcnow()
return max(dates)
@property
def schlagworte_list(self):
schlagworte = [s.name for s in self.schlagworte]
return ', '.join(schlagworte)
def to_ref(self):
return {
'id': self.id,
'source_url': self.source_url,
'key': self.key,
'wahlperiode': self.wahlperiode,
'titel': self.titel
}
def to_dict(self):
data = self.to_ref()
data.update({
'typ': self.typ,
'klasse': self.klasse,
'initiative': self.initiative,
'stand': self.stand,
'signatur': self.signatur,
'gesta_id': self.gesta_id,
'eu_dok_nr': self.eu_dok_nr,
'eur_lex_pdf': self.eur_lex_pdf,
'eur_lex_url': self.eur_lex_url,
'consilium_url': self.consilium_url,
'abstrakt': self.abstrakt,
'zustimmungsbeduerftig': self.zustimmungsbeduerftig,
'sachgebiet': self.sachgebiet,
'schlagworte': [s.name for s in self.schlagworte],
'positionen': [p.to_ref() for p in self.positionen],
'referenzen': [r.to_ref() for r in self.referenzen],
'created_at': self.created_at,
'updated_at': self.updated_at
})
return data
def to_index(self):
data = super(Ablauf, self).to_index()
data['positionen'] = [p.to_dict() for p in \
self.positionen]
data['positionen'] = [p.to_dict() for p in self.positionen]
dates = [
p['date'] for p in data['positionen'] if p['date'] is not None
]
if len(dates):
data['date'] = max(dates)
return data
