def find_by_key(self, key):
"""Suchen eines Benutzers mit vorgegebener User ID. Da diese eindeutig ist,
wird genau ein Objekt zurückgegeben.
:param key Primärschlüsselattribut (->DB)
:return User-Objekt, das dem übergebenen Schlüssel entspricht, None bei
nicht vorhandenem DB-Tupel.
"""
result = None
cursor = self._cnx.cursor()
command = "SELECT id, name, email, google_user_id FROM users WHERE id={}".format(
key)
cursor.execute(command)
tuples = cursor.fetchall()
try:
(id, name, email, user_id) = tuples[0]
user = User()
user.set_id(id)
user.set_name(name)
user.set_email(email)
user.set_user_id(user_id)
result = user
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_name(self, name):
"""Auslesen aller Benutzer anhand des Benutzernamens.
:param name Name der zugehörigen Benutzer.
:return Eine Sammlung mit User-Objekten, die sämtliche Benutzer
mit dem gewünschten Namen enthält.
"""
result = []
cursor = self._cnx.cursor()
command = "SELECT id, name, email, google_user_id FROM users WHERE name LIKE '{}' ORDER BY name".format(
name)
cursor.execute(command)
tuples = cursor.fetchall()
for (id, name, email, user_id) in tuples:
user = User()
user.set_id(id)
user.set_name(name)
user.set_email(email)
user.set_user_id(user_id)
result.append(user)
self._cnx.commit()
cursor.close()
return result
def find_by_google_user_id(self, google_user_id):
"""Suchen eines Benutzers mit vorgegebener Google ID. Da diese eindeutig ist,
wird genau ein Objekt zurückgegeben.
:param google_user_id die Google ID des gesuchten Users.
:return User-Objekt, das die übergebene Google ID besitzt,
None bei nicht vorhandenem DB-Tupel.
"""
result = None
cursor = self._cnx.cursor()
command = "SELECT id, name, email, google_user_id FROM users WHERE google_user_id='{}'".format(
google_user_id)
cursor.execute(command)
tuples = cursor.fetchall()
try:
(id, name, email, google_user_id) = tuples[0]
u = User()
u.set_id(id)
u.set_name(name)
u.set_email(email)
u.set_user_id(google_user_id)
result = u
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_email(self, mail_address):
"""Auslesen aller Benutzer anhand der zugeordneten E-Mail-Adresse.
:param mail_address E-Mail-Adresse der zugehörigen Benutzer.
:return Eine Sammlung mit User-Objekten, die sämtliche Benutzer
mit der gewünschten E-Mail-Adresse enthält.
"""
result = None
cursor = self._cnx.cursor()
command = "SELECT id, name, email, google_user_id FROM users WHERE email={}".format(
mail_address)
cursor.execute(command)
tuples = cursor.fetchall()
try:
(id, name, email, user_id) = tuples[0]
user = User()
user.set_id(id)
user.set_name(name)
user.set_email(email)
user.set_user_id(user_id)
result = user
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, mail, google_id):
"""User erstellen"""
user = User()
user.set_name(name)
user.set_mail(mail)
user.set_google_id(google_id)
user.set_id(1)
with UserMapper() as mapper:
return mapper.insert(user)
def post(self):
"""User erstellen"""
adm = ProjectAdministration()
user = User.from_dict(api.payload)
if user is not None:
c = adm.create_user(user.get_name(), user.get_mail(),
user.get_google_id())
return c, 200
else:
return '', 500
def post(self):
adm = ShoppingAdministration()
""" try:
"""
proposal = User.from_dict(api.payload)
if proposal is not None:
d = adm.insert_user(proposal)
""" if proposal is not None:
c = adm.create_user(proposal.get_name(),proposal.get_email(),proposal.get_firebase_id())
return c, 200 """
""" except Exception as e:
def put(self, id):
"""User wird aktualisiert"""
adm = ProjectAdministration()
user = User.from_dict(api.payload)
if user is None:
return "User konnte nicht geändert werden", 500
else:
user.set_id(id)
adm.save_user(user)
return "User wurde erfolgreich geändert", 200
def wrapper(*args, **kwargs):
# Verify Firebase auth.
id_token = request.cookies.get("token")
error_message = None
claims = None
objects = None
if id_token:
try:
# Verify the token against the Firebase Auth API. This example
# verifies the token on each page load. For improved performance,
# some applications may wish to cache results in an encrypted
# session store (see for instance
# http://flask.pocoo.org/docs/1.0/quickstart/#sessions).
claims = google.oauth2.id_token.verify_firebase_token(
id_token, firebase_request_adapter)
if claims is not None:
adm = ProjectAdministration()
google_id = claims.get("user_id")
mail = claims.get("email")
name = claims.get("name")
user = adm.get_user_by_google_id(google_id)
if user is not None:
"""Fall: Der Benutzer ist unserem System bereits bekannt.
Wir gehen davon aus, dass die google_id sich nicht ändert.
Wohl aber können sich der zugehörige Name (name&firstname),
die E-Mail-Adresse (mail) und die Role (role_id) ändern.
Daher werden diese vier Daten sicherheitshalber
in unserem System geupdated."""
u = User()
u.set_name(name)
u.set_mail(mail)
adm.save_user(u)
else:
"""Fall: Der Benutzer war bislang noch nicht eingelogged.
Wir legen daher ein neues User-Objekt an, um dieses ggf. später
nutzen zu können.
"""
user = adm.create_user(name, mail, google_id)
print(request.method, request.path, "angefragt durch:",
name, mail, google_id)
objects = function(*args, **kwargs)
return objects
else:
return print('Fall 1'), '', 401 # UNAUTHORIZED !!!
except ValueError as exc:
# This will be raised if the token is expired or any other
# verification checks fail.
error_message = str(exc)
return print('Fall 2'), exc, 401 # UNAUTHORIZED !!!
return print('Fall 3'), 401 # UNAUTHORIZED !!!
def find_all(self):
"""Auslesen aller Benutzer unseres Systems.
:return Eine Sammlung mit User-Objekten, die sämtliche Benutzer
des Systems repräsentieren.
"""
result = []
cursor = self._cnx.cursor()
cursor.execute("SELECT * from users")
tuples = cursor.fetchall()
for (id, name, email, user_id) in tuples:
user = User()
user.set_id(id)
user.set_name(name)
user.set_email(email)
user.set_user_id(user_id)
result.append(user)
self._cnx.commit()
cursor.close()
return result
def put(self, id):
"""
Updates an specific user object.
The object is determined by the ``id`` in the URI.
"""
adm = ShoppingAdministration()
c = User.from_dict(api.payload)
if c is not None:
c.set_id(id)
adm.save_user(c)
return 'saved', 200
else:
return 'error', 500
def find_by_role_id(self, role_id):
"""Suchen eines Users anhand seiner Rollen-ID"""
result = []
cursor = self._cnx.cursor()
command = "SELECT * FROM user WHERE role_id like '{}'".format(role_id)
cursor.execute(command)
tuples = cursor.fetchall()
for (id, name, mail, google_id, role_id, create_time) in tuples:
user = User()
user.set_id(id)
user.set_name(name)
user.set_mail(mail)
user.set_google_id(google_id)
user.set_role_id(role_id)
user.set_create_time(create_time)
result.append(user)
self._cnx.commit()
cursor.close()
return result
def find_by_key(self, id):
"""Suchen eines User mit vorgegebener ID"""
result = []
cursor = self._cnx.cursor()
command = "SELECT * FROM user WHERE id like '{}'".format(id)
cursor.execute(command)
tuples = cursor.fetchall()
if len(tuples) != 0:
for (id, name, mail, google_id, role_id, create_time) in tuples:
user = User()
user.set_id(id)
user.set_name(name)
user.set_mail(mail)
user.set_google_id(google_id)
user.set_role_id(role_id)
user.set_create_time(create_time)
result.append(user)
result = user
else:
result = None
self._cnx.commit()
cursor.close()
return result
def find_all(self):
"""Auslesen aller User"""
result = []
cursor = self._cnx.cursor()
command = "SELECT * FROM user"
cursor.execute(command)
tuples = cursor.fetchall()
for (id, name, mail, google_id, role_id, create_time) in tuples:
user = User()
user.set_id(id)
user.set_name(name)
user.set_mail(mail)
user.set_google_id(google_id)
user.set_role_id(role_id)
user.set_create_time(create_time)
result.append(user)
self._cnx.commit()
cursor.close()
return result