def update(self, person: Person):
"""Aktualisieren eines Person-Objekts in der Datenbank anhand seiner ID
:param person: Das Person-Objekt, das in der Datenbank übergeschrieben werden soll
"""
cursor = self._cnx.cursor()
command = (
"UPDATE personen SET `name`=%s, email=%s, google_user_id=%s, `alter`=%s, wohnort=%s, studiengang=%s, "
"semester=%s, profil_id=%s WHERE id=%s")
data = (
person.get_name(),
person.get_email(),
person.get_google_user_id(),
person.get_alter(),
person.get_wohnort(),
person.get_studiengang(),
person.get_semester(),
person.get_profil_id(),
person.get_id(),
)
cursor.execute(command, data)
self._cnx.commit()
cursor.close()
def delete(self, person: Person):
"""Löschen der Daten eines Person-Objekts aus der Datenbank.
:param person: Das aus der Datenbank zu löschende Person-Objekt
"""
cursor = self._cnx.cursor()
command = "DELETE FROM personen WHERE id={}".format(person.get_id())
cursor.execute(command)
self._cnx.commit()
cursor.close()
def put(self, id):
"""Update einer bestimmten Person.
"""
adm = ProjectAdministration()
p = Person.from_dict(api.payload)
if p is not None:
p.set_id(id)
adm.save_person(p)
return '', 200
else:
return '', 500
def put(self, id):
"""Update eines bestimmten Person-Objekts.
Die über die URI übermittelte ID überschreibt das ID-Attribut des im Payload der Anfrage übermittelten
Objekts.
"""
adm = Admin()
p = Person.from_dict(api.payload)
if p is not None:
p.set_id(id)
adm.save_person(p)
return "", 200
else:
return "", 500
def post(self):
"""Anlegen eines neuen Person-Objekts.
"""
adm = ProjectAdministration()
proposal = Person.from_dict(api.payload)
if proposal is not None:
pers = adm.create_person(proposal.get_creation_time(),
proposal.get_name(), proposal.get_role(),
proposal.get_email(),
proposal.get_google_user_id())
return pers, 200
else:
# Wenn irgendetwas schiefgeht, dann geben wir nichts zurück und werfen einen Server-Fehler.
return '', 500
def post(self):
"""
Anlegen eines neuen Person-Objekts.
Die vom Client gesendeten Daten werden über die in jeder BO-Klasse verfügbaren Methode from_dict in das
jeweilige BO überführt und anschließend in die Datenbank geschrieben.
"""
adm = Admin()
proposal = Person.from_dict(api.payload)
if proposal is not None:
p = adm.create_person(
proposal.get_name(),
proposal.get_email(),
proposal.get_google_user_id(),
proposal.get_alter(),
proposal.get_studiengang(),
proposal.get_wohnort(),
proposal.get_semester(),
proposal.get_profil_id(),
)
return p, 200
else:
return "", 500
def find_all(self):
"""Auslesen aller Person-Objekte
:return: Sammlung mit Person-Objekten
"""
result = []
cursor = self._cnx.cursor()
cursor.execute("SELECT * from personen")
tuples = cursor.fetchall()
for (
id,
erstellungszeitpunkt,
name,
email,
google_user_id,
alter,
wohnort,
studiengang,
semester,
profil_id,
) in tuples:
person = Person()
person.set_id(id)
person.set_erstellungszeitpunkt(erstellungszeitpunkt)
person.set_name(name)
person.set_email(email)
person.set_google_user_id(google_user_id)
person.set_alter(alter)
person.set_studiengang(studiengang)
person.set_wohnort(wohnort)
person.set_semester(semester)
person.set_profil_id(profil_id)
result.append(person)
self._cnx.commit()
cursor.close()
return result
"""
cursor = self._cnx.cursor()
command = "DELETE FROM personen WHERE id={}".format(person.get_id())
cursor.execute(command)
self._cnx.commit()
cursor.close()
"""Testbereich, ob die Klasse funktioniert"""
if __name__ == "__main__":
with PersonMapper() as mapper:
neu = Person()
neu.set_name("Moritz Mulser")
neu.set_email("*****@*****.**")
neu.set_google_user_id("ljknsdfjknbfdjkfsdjknfYO")
neu.set_alter(23)
neu.set_wohnort("Böblingen")
neu.set_studiengang("WI7")
neu.set_semester(4)
neu.set_profil_id(5)
mapper.insert(neu)
print("Find all")
result = mapper.find_all()
for p in result:
print(
p.get_id(),
def create_user(self, name, email, google_user_id):
p = Person()
p.set_id(1)
p.set_role(1)
p.set_name(name)
p.set_email(email)
p.set_google_user_id(google_user_id)
with PersonMapper() as mapper:
return mapper.insert_google_user(p)
def insert(self, person: Person):
"""Einfügen eines Person-Objekts in die Datenbank.
Der Primärschlüssel wird dabei überprüft und ggf. berechtigt.
:param: person: Das zu speichernde Person-Objekt
:return: Das bereits übergebene Person-Objekt, jeodch mit ggf, korrigierter ID.
"""
cursor = self._cnx.cursor()
cursor.execute("SELECT MAX(id) AS maxid FROM personen")
tuples = cursor.fetchall()
for maxid in tuples:
if maxid[0] is not None:
person.set_id(maxid[0] + 1)
else:
person.set_id(1)
command = (
"INSERT INTO personen (id, erstellungszeitpunkt, name, email, google_user_id, `alter`, wohnort, "
"studiengang, semester, profil_id) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)"
)
data = (
person.get_id(),
person.get_erstellungszeitpunkt(),
person.get_name(),
person.get_email(),
person.get_google_user_id(),
person.get_alter(),
person.get_wohnort(),
person.get_studiengang(),
person.get_semester(),
person.get_profil_id(),
)
cursor.execute(command, data)
self._cnx.commit()
cursor.close()
return person
def find_all(self):
result = []
cursor = self._cnx.cursor()
cursor.execute("SELECT id, creation_time, name, role, email, google_user_id FROM person")
tuples = cursor.fetchall()
for (id, creation_time, name, role, email, google_user_id) in tuples:
person = Person()
person.set_id(id)
person.set_creation_time(creation_time)
person.set_name(name)
person.set_role(role)
person.set_email(email)
person.set_google_user_id(google_user_id)
result.append(person)
self._cnx.commit()
cursor.close()
return result
def find_by_id(self, id):
"""Suchen einer Person mit vorgegebener id. Da diese eindeutig ist,
wird genau ein Objekt zurückgegeben.
:param id Primärschlüsselattribut (->DB)
:return Konto-Objekt, das dem übergebenen Schlüssel entspricht, None bei
nicht vorhandenem DB-Tupel.
"""
result = None
cursor = self._cnx.cursor()
command = "SELECT id, creation_time, name, role, email, google_user_id FROM person WHERE id={}".format(id)
cursor.execute(command)
tuples = cursor.fetchall()
if tuples[0] is not None:
(id, creation_time, name, role, email, google_user_id) = tuples[0]
person = Person()
person.set_id(id)
person.set_creation_time(creation_time)
person.set_name(name)
person.set_role(role)
person.set_email(email)
person.set_google_user_id(google_user_id)
result = person
self._cnx.commit()
cursor.close()
return result
def find_by_google_user_id(self, google_user_id):
result = None
cursor = self._cnx.cursor()
command = "SELECT id, name, role, email, google_user_id FROM person WHERE google_user_id = '{}'".format(
google_user_id)
cursor.execute(command)
tuples = cursor.fetchall()
try:
(id, name, role, email, google_user_id) = tuples[0]
person = Person()
person.set_id(id)
person.set_name(name)
person.set_role(role)
person.set_email(email)
person.set_google_user_id(google_user_id)
result = person
except IndexError:
result = None
self._cnx.commit()
cursor.close()
return result
def find_person_by_role(self, role):
result = []
cursor = self._cnx.cursor()
command = "SELECT id, creation_time, name, role, email, google_user_id FROM person WHERE role={}".format(role)
cursor.execute(command)
tuples = cursor.fetchall()
try:
(id, creation_time, name, role, email, google_user_id) = tuples[0]
person = Person()
person.set_id(id)
person.set_creation_time(creation_time)
person.set_name(name)
person.set_role(role)
person.set_email(email)
person.set_google_user_id(google_user_id)
result = person
except IndexError:
"""Der IndexError wird oben beim Zugriff auf tuples[0] auftreten, wenn der vorherige SELECT-Aufruf
keine Tupel liefert, sondern tuples = cursor.fetchall() eine leere Sequenz zurück gibt."""
result = None
self._cnx.commit()
cursor.close()
return result
def find_by_konversation_id(self, konversation_id):
"""Auslesen eines Person-Objekts mit der gegebenen Konversation ID
:param konversation_id: Konversation ID
:return: Ein einzelnes Person-Objekt, welches an der gegebener Konversation teilnimmt
"""
result = []
cursor = self._cnx.cursor()
command = ("SELECT L.* FROM personen AS L "
"LEFT OUTER JOIN chat_teilnahmen AS R ON R.person_id=L.id "
"WHERE R.konversation_id={}".format(konversation_id))
cursor.execute(command)
tuples = cursor.fetchall()
for (
id,
erstellungszeitpunkt,
name,
email,
google_user_id,
alter,
wohnort,
studiengang,
semester,
profil_id,
) in tuples:
person = Person()
person.set_id(id)
person.set_erstellungszeitpunkt(erstellungszeitpunkt)
person.set_name(name)
person.set_email(email)
person.set_google_user_id(google_user_id)
person.set_alter(alter)
person.set_studiengang(studiengang)
person.set_wohnort(wohnort)
person.set_semester(semester)
person.set_profil_id(profil_id)
result.append(person)
self._cnx.commit()
cursor.close()
return result
def find_by_profil_id(self, profil_id: int):
"""Auslesen eines Person-Objekts mit der gegebenen Profil ID
:param profil_id: Profil ID
:return: das gesuchte Person-Objekt
"""
result = None
cursor = self._cnx.cursor()
command = (
"SELECT id, erstellungszeitpunkt, `name`, email, google_user_id, `alter`, wohnort, studiengang, semester, "
"profil_id FROM personen WHERE profil_id={}".format(profil_id))
cursor.execute(command)
tuples = cursor.fetchall()
try:
(
id,
erstellungszeitpunkt,
name,
email,
google_user_id,
alter,
wohnort,
studiengang,
semester,
profil_id,
) = tuples[0]
person = Person()
person.set_id(id)
person.set_erstellungszeitpunkt(erstellungszeitpunkt)
person.set_name(name)
person.set_email(email)
person.set_google_user_id(google_user_id)
person.set_alter(alter)
person.set_studiengang(studiengang)
person.set_wohnort(wohnort)
person.set_semester(semester)
person.set_profil_id(profil_id)
result = person
except IndexError:
"""Der IndexError wird oben beim Zugriff auf tuples[0] auftreten, wenn der vorherige SELECT-Aufruf
keine Tupel liefert, sondern tuples = cursor.fetchall() eine leere Sequenz zurück gibt."""
result = None
self._cnx.commit()
cursor.close()
return result
from server.bo.Person import Person
from server.bo.Student import Student
p = Person()
p.set_id(1)
p.set_rolle(Person.ROLLE_DOZENT)
p.set_name("Peter Thies")
print(p)
s = Student()
s.set_id(2)
s.set_name("Daria")
print(s)
def find_all(self):
"""Auslesen aller Personen aus der Datenbank
:return Alle Person-Objekte im System
"""
result = []
cursor = self._connection.cursor()
command = "SELECT id, name, email, google_user_id, rolle FROM personen"
cursor.execute(command)
tuples = cursor.fetchall()
for (id, name, email, google_user_id, rolle) in tuples:
person = Person()
person.set_id(id)
person.set_name(name)
person.set_email(email)
person.set_google_user_id(google_user_id)
if rolle == "Dozent":
person.set_rolle(Person.ROLLE_DOZENT)
elif rolle == "Admin":
person.set_rolle(Person.ROLLE_ADMIN)
result.append(person)
self._connection.commit()
cursor.close()
return result
def find_by_google_user_id(self, google_user_id):
"""Suchen einer Person nach der übergebenen Google User ID.
:param google_user_id Google User ID einer Person aus der Datenbank
:return Person-Objekt, welche mit der Google User ID übereinstimmt,
None wenn kein Eintrag gefunden wurde
"""
result = None
cursor = self._connection.cursor()
command = "SELECT id, name, email, google_user_id, rolle FROM personen WHERE google_user_id='{}'".format(
google_user_id)
cursor.execute(command)
tuples = cursor.fetchall()
try:
(id, name, email, google_user_id, rolle) = tuples[0]
person = Person()
person.set_id(id)
person.set_name(name)
person.set_email(email)
person.set_google_user_id(google_user_id)
if rolle == "Dozent":
person.set_rolle(Person.ROLLE_DOZENT)
elif rolle == "Admin":
person.set_rolle(Person.ROLLE_ADMIN)
result = person
except IndexError:
"""Der IndexError wird oben beim Zugriff auf tuples[0] auftreten, wenn der vorherige SELECT-Aufruf
keine Tupel liefert, sondern tuples = cursor.fetchall() eine leere Sequenz zurück gibt."""
result = None
return result
def find_by_key(self, key: int):
"""Suchen einer Person mit gegebener Person-ID
:param: key: Person ID, Primärschlüsselattribut
:return: Ein einzelnes Person-Objekt mit gegebender Person ID, None bei nicht vorhandenem DB-Tupel
"""
result = None
cursor = self._cnx.cursor()
command = (
"SELECT id, erstellungszeitpunkt, `name`, email, google_user_id, `alter`, wohnort, studiengang, semester, "
"profil_id FROM personen WHERE id={}".format(key))
cursor.execute(command)
tuples = cursor.fetchall()
try:
(
id,
erstellungszeitpunkt,
name,
email,
google_user_id,
alter,
wohnort,
studiengang,
semester,
profil_id,
) = tuples[0]
person = Person()
person.set_id(id)
person.set_erstellungszeitpunkt(erstellungszeitpunkt)
person.set_name(name)
person.set_email(email)
person.set_google_user_id(google_user_id)
person.set_alter(alter)
person.set_studiengang(studiengang)
person.set_wohnort(wohnort)
person.set_semester(semester)
person.set_profil_id(profil_id)
result = person
except IndexError:
"""Der IndexError wird oben beim Zugriff auf tuples[0] auftreten, wenn der vorherige SELECT-Aufruf
keine Tupel liefert, sondern tuples = cursor.fetchall() eine leere Sequenz zurück gibt."""
result = None
self._cnx.commit()
cursor.close()
return result
def create_person(self, creation_time, name, role, email, google_user_id):
"""Eine Person anlegen"""
p = Person()
p.set_id(1)
p.set_creation_time(creation_time)
p.set_name(name)
p.set_role(role)
p.set_email(email)
p.set_google_user_id(google_user_id)
with PersonMapper() as mapper:
return mapper.insert(p)