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
Esempio n. 3
0
    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
Esempio n. 4
0
    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
Esempio n. 5
0
    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 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 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)
Esempio n. 8
0
    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
Esempio n. 9
0
    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
Esempio n. 10
0
    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
Esempio n. 11
0
    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
Esempio n. 12
0
    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
Esempio n. 13
0
        """
        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(),
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)