def post(self, shopping_list_id):
""" Wir verwenden Namen, amount, article, Unit, Purchasing_user,
retailer und shoppinglist des Proposals für die Erzeugung
eines Gruppen-Objekts. Das serverseitig erzeugte
Objekt ist das maßgebliche und
wird auch dem Client zurückgegeben. """
adm = Administration()
sl = adm.get_shopping_list_by_id(shopping_list_id)
proposal = ListEntry.from_dict(api.payload)
if sl is not None and proposal is not None:
result = adm.create_list_entry(proposal.get_name(),
proposal.get_amount(),
proposal.get_article(),
proposal.get_unit(),
proposal.get_purchasing_user(),
proposal.get_retailer(),
proposal.get_shopping_list(),
proposal.is_standardarticle())
if proposal.is_standardarticle():
shopping_list = adm.get_shopping_list_by_id(
proposal.get_shopping_list())
group = adm.get_group_by_id(shopping_list.get_group())
adm.add_standardarticle_to_group(result, group)
return result, 200
else:
return 'ShoppingList unknown or payload not valid', 500
def delete(self, article_id):
"""Löschen eines bestimmten Artikel-Objekts.
Das zu löschende Objekt wird durch die article_id in dem URI bestimmt.
"""
adm = Administration()
adm.delete_article(article_id)
return 'deleted', 200
def get(self, article_id):
"""Auslesen eines bestimmten Artikel-Objekts.
Das auszulesende Objekt wird durch die article_id in dem URI bestimmt.
"""
adm = Administration()
art = adm.get_article_by_id(article_id)
return art
def get(self, name):
""" Auslesen von Artikel-Objekten, die durch den Namen bestimmt werden.
Die auszulesenden Objekte werden durch name in dem URI bestimmt.
"""
adm = Administration()
us = adm.get_article_by_name(name)
return us
def get(self):
"""Auslesen aller Gruppen-Objekte.
Sollten keine Gruppen-Objekte verfügbar sein, so wird eine
leere Sequenz zurückgegeben."""
adm = Administration()
group_list = adm.get_all_groups()
return group_list
def get(self, group_id):
"""Auslesen eines bestimmten Gruppen-Objekts.
Das auszulesende Objekt wird durch die group_id in dem URI bestimmt.
"""
adm = Administration()
grp = adm.get_group_by_id(group_id)
return grp
def get(self):
"""Auslesen aller User-Objekte.
Sollten keine User-Objekte verfügbar sein,
so wird eine leere Sequenz zurückgegeben."""
adm = Administration()
user_list = adm.get_all_users()
return user_list
def get(self, google_id):
"""Auslesen eines bestimmten User-Objekts.
Das auszulesende Objekt wird durch die google_id in dem URI bestimmt.
"""
adm = Administration()
usr = adm.get_user_by_google_id(google_id)
return usr
def get(self, name):
""" Auslesen von Retailer-Objekten, die durch den Namen bestimmt werden
Die auszulesenden Objekte werden durch name in dem URI bestimmt.
"""
adm = Administration()
rtl = adm.get_retailers_by_name(name)
return rtl
def get(self, retailer_id):
"""Auslesen eines bestimmten Retailer-Objekts.
Das auszulesende Objekt wird durch die retailer_id
in dem URI bestimmt.
"""
adm = Administration()
rtl = adm.get_retailer_by_id(retailer_id)
return rtl
def post(self, shopping_list_id):
"""Einkaufsliste archivieren"""
adm = Administration()
sl = adm.get_shopping_list_by_id(shopping_list_id)
if sl is not None:
result = adm.archive_shopping_list(sl)
return result
else:
return "ShoppingList not found", 500
def get(self, name):
"""Auslesen von Shoppinglisten-Objekten, die durch den Namen
bestimmt wurden.
Die auszulesenden Objekte werden durch name in dem URI bestimmt.
"""
adm = Administration()
le = adm.get_shopping_list_by_name(name)
return le
def get(self, list_entry_id):
"""Auslesen eines bestimmten Listeneintrag-Objekts.
Das auszulesende Objekt wird durch die list_entry_id
in dem URI bestimmt.
"""
adm = Administration()
le = adm.get_list_entry_by_id(list_entry_id)
return le
def wrapper(*args, **kwargs):
objects = function(*args, **kwargs)
return objects
# 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 = Administration()
google_id = claims.get("user_id")
email = 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_user_id sich nicht ändert.
Wohl aber können sich der zugehörige Klarname (name) und die
E-Mail-Adresse ändern. Daher werden diese beiden Daten sicherheitshalber
in unserem System geupdated."""
user.set_name(name)
user.set_email(email)
adm.save_user(user)
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, email, google_id)
print(request.method, request.path, "angefragt durch:",
name, email)
objects = function(*args, **kwargs)
return objects
else:
return '', 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 exc, 401 # UNAUTHORIZED !!!
return '', 401 # UNAUTHORIZED !!!
def delete(self, group_id, list_entry_id):
"""Lösche den Standardartikel einer Gruppe"""
adm = Administration()
grp = adm.get_group_by_id(group_id)
le = adm.get_list_entry_by_id(list_entry_id)
if grp is not None and le is not None:
result = adm.delete_standardarticle(le, grp)
return "Deleted standardarticle!", 200
else:
return "Group or Listentry not found", 500
def get(self, group_id):
"""Auslesen von Listeneintrag-Objekten (Markiert als Standardartikel),
die zu einer bestimmten Gruppe gehören."""
adm = Administration()
grp = adm.get_group_by_id(group_id)
if grp is not None:
result = adm.get_standardarticles_by_group_id(group_id)
return result
else:
return "Group not found", 500
def get(self, retailer_id):
"""Auslesen von Listeneintrag-Objekten, die zu einem bestimmten
Retailer gehören."""
adm = Administration()
rtl = adm.get_retailer_by_id(retailer_id)
if rtl is not None:
result = adm.get_list_entries_by_retailer_id(retailer_id)
return result
else:
return "Retailer not found", 500
def get(self, article_id):
"""Auslesen von Listeneintrag-Objekten die zu einem bestimmten
Artikel gehören."""
adm = Administration()
art = adm.get_article_by_id(article_id)
if art is not None:
result = adm.get_list_entries_by_article_id(article_id)
return result
else:
return "Article not found", 500
def get(self, user_id):
"""Auslesen von Listeneintrag-Objekten, die zu einem bestimmten
User gehören."""
adm = Administration()
us = adm.get_user_by_id(user_id)
if us is not None:
listentry_list = adm.get_list_entries_by_user_id(user_id, True)
return listentry_list
else:
return "User not found", 500
def get(self, shopping_list_id):
"""Auslesen von Listeneintrag-Objekten die bereits gecheckt wurden """
adm = Administration()
sl = adm.get_shopping_list_by_id(shopping_list_id)
if sl is not None:
result = adm.get_checked_list_entries_by_shopping_list_id(
shopping_list_id)
return result
else:
return "Shopping List not found", 500
def get(self, shopping_list_id):
"""Auslesen aller Listeneintrag-Objekte einer bestimmten Shoppingliste.
"""
adm = Administration()
le = adm.get_shopping_list_by_id(shopping_list_id)
if le is not None:
listentry_list = adm.get_list_entries_by_shopping_list_id(le)
return listentry_list
else:
return "ShoppingList not found", 500
def get(self, group_id):
"""Auslesen eines neuen Shoppinglisten-Objekts, das zu einer bestimmten
Grruppe gehört."""
adm = Administration()
sl = adm.get_group_by_id(group_id)
if sl is not None:
shopping_lists = adm.get_shopping_lists_by_group_id(sl)
return shopping_lists
else:
return "Group not found", 500
def put(self, article_id):
"""Update eines bestimmten Artikel-Objekts."""
adm = Administration()
art = Article.from_dict(api.payload)
if art is not None:
art.set_id(article_id)
adm.save_article(art)
return '', 200
else:
return '', 500
def put(self, list_entry_id):
"""Update eines bestimmten Listeneintrag-Objekts."""
adm = Administration()
le = ListEntry.from_dict(api.payload)
if le is not None:
le.set_id(list_entry_id)
adm.save_list_entry(le)
return '', 200
else:
return '', 500
def put(self, user_id):
"""Update eines bestimmten User-Objekts."""
adm = Administration()
usr = User.from_dict(api.payload)
if usr is not None:
usr.set_id(user_id)
adm.save_user(usr)
return '', 200
else:
return '', 500
def put(self, group_id):
"""Update eines bestimmten Gruppen-Objekts."""
adm = Administration()
grp = Group.from_dict(api.payload)
if grp is not None:
grp.set_id(group_id)
adm.save_group(grp)
return '', 200
else:
return '', 500
def get(self, user_id):
"""Auslesen aller Gruppen-Objekte eines bestimmten Users.
"""
adm = Administration()
us = adm.get_user_by_id(user_id)
if us is not None:
group_list = adm.get_groups_by_user_id(user_id)
return group_list
else:
return "User not found", 500
def post(self, group_id, user_id):
"""Füge ein bestimmtes User Objekt einer bestimmten Gruppe hinzu."""
adm = Administration()
grp = adm.get_group_by_id(group_id)
us = adm.get_user_by_id(user_id)
if grp is not None and us is not None:
result = adm.add_member_to_group(grp, us)
return result
else:
return "Group or User not found", 500
def put(self, shopping_list_id):
"""Update eines bestimmten Shoppinglisten-Objekts."""
adm = Administration()
sl = ShoppingList.from_dict(api.payload)
if sl is not None:
sl.set_id(shopping_list_id)
adm.save_shopping_list(sl)
return '', 200
else:
return '', 500
def delete(self, group_id, user_id):
"""Lösche ein bestimmtes User Objekt von einer bestimmten Gruppe."""
adm = Administration()
grp = adm.get_group_by_id(group_id)
us = adm.get_user_by_id(user_id)
if grp is not None and us is not None:
result = adm.remove_member_from_group(grp, us)
return result
else:
return "Group or User not found", 500