class Wahlkreis(db.Model, ModelCore):
__tablename__ = 'wahlkreis'
nummer = db.Column(db.Unicode)
name = db.Column(db.Unicode)
url = db.Column(db.Unicode)
mdbs = db.relationship('Rolle', backref='wahlkreis',
lazy='dynamic')
plzs = db.relationship('Postleitzahl', backref='wahlkreis',
lazy='dynamic')
def to_ref(self):
return {
'id': self.id,
'nummer': self.nummer,
'name': self.name,
'url': self.url,
}
def to_dict(self):
data = self.to_ref()
data.update({
'mdbs': [m.to_ref() for m in self.mdbs],
'plzs': [p.plz for p in self.plzs],
'created_at': self.created_at,
'updated_at': self.updated_at,
})
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 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 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 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 Gremium(db.Model, ModelCore):
__tablename__ = 'gremium'
vorsitz_id = db.Column(db.Integer, db.ForeignKey('person.id'))
stellv_vorsitz_id = db.Column(db.Integer, db.ForeignKey('person.id'))
source_url = db.Column(db.Unicode)
rss_url = db.Column(db.Unicode)
name = db.Column(db.Unicode)
url = db.Column(db.Unicode)
key = db.Column(db.Unicode)
typ = db.Column(db.Unicode)
aufgabe = db.Column(db.Unicode)
image_url = db.Column(db.Unicode)
image_copyright = db.Column(db.Unicode)
zuweisungen = db.relationship('Zuweisung',
backref='gremium',
lazy='dynamic')
def to_dict(self):
return {
'id': self.id,
'vorsitz': self.vorsitz.to_ref() if \
self.vorsitz else None,
'stellv_vorsitz': self.stellv_vorsitz.to_ref() if \
self.stellv_vorsitz else None,
'source_url': self.source_url,
'rss_url': self.rss_url,
'name': self.name,
'url': self.url,
'key': self.key,
'typ': self.typ,
'aufgabe': self.aufgabe,
'image_url': self.image_url,
'image_copyright': self.image_copyright,
'created_at': self.created_at,
'updated_at': self.updated_at,
'obleute': [m.to_ref() for m in self.obleute],
'mitglieder': [m.to_ref() for m in self.mitglieder],
'stellvertreter': [m.to_ref() for m in self.stellvertreter],
}
def to_ref(self):
return {
'id': self.id,
'source_url': self.source_url,
'name': self.name,
'key': self.key
}
class Rede(db.Model, ModelCore):
__tablename__ = 'rede'
webtv_id = db.Column(db.Integer())
sitzung_id = db.Column(db.Integer, db.ForeignKey('sitzung.id'))
debatte_id = db.Column(db.Integer, db.ForeignKey('debatte.id'))
redner_id = db.Column(db.Integer, db.ForeignKey('person.id'))
zitate = db.relationship('Zitat',
backref='rede',
lazy='dynamic',
order_by='Zitat.sequenz.asc()')
@property
def titel(self):
return "%s: %s" % (self.debatte.titel, self.redner.name)
@property
def text(self):
zitat = self.zitate.first()
return zitat.text
def to_ref(self):
return {
'id': self.id,
'webtv_id': self.webtv_id,
'redner': self.redner.fingerprint if self.redner else None,
}
def to_dict(self):
data = self.to_ref()
data.update({
'sitzung': self.sitzung.to_ref() if self.sitzung else None,
'debatte': self.debatte.to_ref() if self.debatte else None,
'created_at': self.created_at,
'updated_at': self.updated_at
})
return data
def to_index(self):
data = super(Rede, self).to_index()
data['sitzung'] = self.sitzung.to_dict()
data['debatte'] = self.debatte.to_dict()
data['zitate'] = [z.to_dict() for z in self.zitate]
return data
class Rolle(db.Model, ModelCore):
__tablename__ = 'rolle'
person_id = db.Column(db.Integer, db.ForeignKey('person.id'))
mdb_id = db.Column(db.Unicode)
status = db.Column(db.Unicode)
funktion = db.Column(db.Unicode)
fraktion = db.Column(db.Unicode)
gewaehlt = db.Column(db.Unicode)
ressort = db.Column(db.Unicode)
land = db.Column(db.Unicode)
austritt = db.Column(db.DateTime)
wahlkreis_id = db.Column(db.Integer, db.ForeignKey('wahlkreis.id'))
beitraege = db.relationship('Beitrag', backref='rolle', lazy='dynamic')
def to_ref(self):
return {
'id': self.id,
'mdb_id': self.mdb_id,
'status': self.status,
'funktion': self.funktion,
'fraktion': self.fraktion,
'ressort': self.ressort,
'land': self.land,
'wahlkreis': self.wahlkreis.to_ref() if self.wahlkreis else None,
}
def to_dict(self):
data = self.to_ref()
data.update({
'person': self.person.to_ref(),
'gewaehlt': self.gewaehlt,
'austritt': self.austritt,
'created_at': self.created_at,
'updated_at': self.updated_at
})
return data
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
class Person(db.Model, ModelCore):
__tablename__ = 'person'
slug = db.Column(db.Unicode)
fingerprint = db.Column(db.Unicode)
source_url = db.Column(db.Unicode)
mdb_id = db.Column(db.Integer)
vorname = db.Column(db.Unicode)
nachname = db.Column(db.Unicode)
adelstitel = db.Column(db.Unicode)
titel = db.Column(db.Unicode)
ort = db.Column(db.Unicode)
geburtsdatum = db.Column(db.Unicode)
religion = db.Column(db.Unicode)
hochschule = db.Column(db.Unicode)
beruf = db.Column(db.Unicode)
berufsfeld = db.Column(db.Unicode)
geschlecht = db.Column(db.Unicode)
familienstand = db.Column(db.Unicode)
kinder = db.Column(db.Unicode)
partei = db.Column(db.Unicode)
land = db.Column(db.Unicode)
bio_url = db.Column(db.Unicode)
bio = db.Column(db.Unicode)
wissenswertes = db.Column(db.Unicode)
telefon = db.Column(db.Unicode)
homepage_url = db.Column(db.Unicode)
angaben = db.Column(db.Unicode)
foto_url = db.Column(db.Unicode)
foto_copyright = db.Column(db.Unicode)
reden_plenum_url = db.Column(db.Unicode)
reden_plenum_rss_url = db.Column(db.Unicode)
twitter_url = db.Column(db.Unicode)
facebook_url = db.Column(db.Unicode)
awatch_url = db.Column(db.Unicode)
rollen = db.relationship('Rolle', backref='person',
lazy='dynamic')
vorsitze = db.relationship('Gremium', backref='vorsitz',
primaryjoin='Person.id == Gremium.vorsitz_id',
lazy='dynamic')
stellv_vorsitze = db.relationship('Gremium', backref='stellv_vorsitz',
primaryjoin='Person.id == Gremium.stellv_vorsitz_id',
lazy='dynamic')
mitglied = db.relationship('Gremium', secondary=mitglieder,
backref=db.backref('mitglieder', lazy='dynamic'))
stellvertreter = db.relationship('Gremium', secondary=stellvertreter,
backref=db.backref('stellvertreter', lazy='dynamic'))
obleute = db.relationship('Gremium', secondary=obleute,
backref=db.backref('obleute', lazy='dynamic'))
beitraege = db.relationship('Beitrag', backref='person',
lazy='dynamic')
reden = db.relationship('Rede', backref='redner',
lazy='dynamic', order_by='Rede.webtv_id.asc()')
zitate = db.relationship('Zitat', backref='person',
lazy='dynamic')
stimmen = db.relationship('Stimme', backref='person',
lazy='dynamic')
@property
def name(self):
name = "%s %s %s" % (self.titel if self.titel else '', \
self.vorname, self.nachname)
if self.ort and len(self.ort):
name += " (%s)" % self.ort
return name.strip()
@property
def has_gremien(self):
if self.vorsitze.count() or \
self.stellv_vorsitze.count() or \
len(self.obleute) or \
len(self.mitglied) or \
len(self.stellvertreter):
return True
return False
@property
def gremien(self):
gremien = OrderedDict()
for vorsitz in self.vorsitze:
gremien[vorsitz] = 'Vorsitz'
for stellv in self.stellv_vorsitze:
gremien[stellv] = 'stellv. Vorsitz'
for obself in self.obleute:
gremien[obself] = 'Obperson'
for mitglied in self.mitglied:
if mitglied not in gremien.keys():
gremien[mitglied] = 'Mitglied'
for stellv in self.stellvertreter:
if stellv not in gremien.keys():
gremien[stellv] = 'stellv. Mitglied'
return gremien.items()
def to_dict(self):
data = {
'id': self.id,
'slug': self.slug,
'name': self.name,
'fingerprint': self.fingerprint,
'source_url': self.source_url,
'mdb_id': self.mdb_id,
'vorname': self.vorname,
'nachname': self.nachname,
'adelstitel': self.adelstitel,
'titel': self.titel,
'ort': self.ort,
'geburtsdatum': self.geburtsdatum,
'religion': self.religion,
'hochschule': self.hochschule,
'beruf': self.beruf,
'berufsfeld': self.berufsfeld,
'geschlecht': self.geschlecht,
'familienstand': self.familienstand,
'kinder': self.kinder,
'partei': self.partei,
'land': self.land,
'bio_url': self.bio_url,
'bio': self.bio,
'wissenswertes': self.wissenswertes,
'homepage_url': self.homepage_url,
'telefon': self.telefon,
'angaben': self.angaben,
'foto_url': self.foto_url,
'foto_copyright': self.foto_copyright,
'reden_plenum_url': self.reden_plenum_url,
'reden_plenum_rss_url': self.reden_plenum_rss_url,
'awatch_url': self.awatch_url,
'twitter_url': self.twitter_url,
'facebook_url': self.facebook_url,
'rollen': [r.to_ref() for r in self.rollen],
'created_at': self.created_at,
'updated_at': self.updated_at
}
return data
def to_ref(self):
return {
'id': self.id,
'name': self.name,
'slug': self.slug
}
