def get(self):
"""Auslesen aller Acount-Objekte.
Sollten keine Account-Objekte verfügbar sein, so wird eine leere Sequenz zurückgegeben."""
adm = BankAdministration()
account_list = adm.get_all_accounts()
return account_list
def post(self):
"""Erstellen einer neuen Buchung (Transaction-Objekt).
**ACHTUNG:** Wir fassen die vom Client gesendeten Daten als Vorschlag auf.
So ist zum Beispiel die Vergabe der ID nicht Aufgabe des Clients.
Selbst wenn der Client eine ID in dem Proposal vergeben sollte, so
liegt es an der BankAdministration (Businesslogik), eine korrekte ID
zu vergeben. *Das korrigierte Objekt wird schließlich zurückgegeben.*
"""
adm = BankAdministration()
proposal = Transaction.from_dict(api.payload)
"""RATSCHLAG: Prüfen Sie stets die Referenzen auf valide Werte, bevor Sie diese verwenden!"""
if proposal is not None:
""" Wir verwenden lediglich Source, Target und Amount des Proposals für die Erzeugung
eines Transaction-Objekts. Das serverseitig erzeugte Objekt ist das maßgebliche und
wird auch dem Client zurückgegeben.
"""
source = proposal.get_source_account()
target = proposal.get_target_account()
value = proposal.get_amount()
result = adm.create_transaction_for(source, target, value)
return result, 200
else:
# Wenn irgendetwas schiefgeht, dann geben wir nichts zurück und werfen einen Server-Fehler.
return '', 500
def get(self):
"""Auslesen aller Customer-Objekte.
Sollten keine Customer-Objekte verfügbar sein, so wird eine leere Sequenz zurückgegeben."""
adm = BankAdministration()
customers = adm.get_all_customers()
return customers
def get(self, id):
"""Auslesen eines bestimmten Account-Objekts.
Das auszulesende Objekt wird durch die ```id``` in dem URI bestimmt.
"""
adm = BankAdministration()
acc = adm.get_account_by_id(id)
return acc
def get(self, lastname):
""" Auslesen von Customer-Objekten, die durch den Nachnamen bestimmt werden.
Die auszulesenden Objekte werden durch ```lastname``` in dem URI bestimmt.
"""
adm = BankAdministration()
cust = adm.get_customer_by_name(lastname)
return cust
def get(self, id):
"""Auslesen eines bestimmten Customer-Objekts.
Das auszulesende Objekt wird durch die ```id``` in dem URI bestimmt.
"""
adm = BankAdministration()
cust = adm.get_customer_by_id(id)
return cust
def delete(self, id):
"""Löschen eines bestimmten Customer-Objekts.
Das zu löschende Objekt wird durch die ```id``` in dem URI bestimmt.
"""
adm = BankAdministration()
cust = adm.get_customer_by_id(id)
adm.delete_customer(cust)
return '', 200
def delete(self, id):
"""Löschen eines bestimmten Account-Objekts.
Das zu löschende Objekt wird durch die ```id``` in dem URI bestimmt.
"""
adm = BankAdministration()
acc = adm.get_account_by_id(id)
adm.delete_account(acc)
return '', 200
def get(self):
"""Auslesen des Kassenkontos (Cash Account) der Bank.
Sollten keine Cash Account-Objekt verfügbar sein, so wird Response Status 500 zurückgegeben."""
adm = BankAdministration()
acc = adm.get_cash_account()
if acc is not None:
return acc
else:
return '', 500
def get(self, id):
"""Auslesen eines bestimmten Transaction-Objekts.
Das auszulesende Objekt wird durch die ```id``` in dem URI bestimmt.
"""
adm = BankAdministration()
trans = adm.get_transaction_by_id(id)
if trans is not None:
return trans
else:
return '', 500 # Wenn es keine Transaktion unter id gibt.
def delete(self, id):
"""Löschen eines bestimmten Transaction-Objekts.
Das zu löschende Objekt wird durch die ```id``` in dem URI bestimmt.
"""
adm = BankAdministration()
trans = adm.get_transaction_by_id(id)
if trans is not None:
adm.delete_transaction(trans)
return '', 200
else:
return '', 500 # Wenn unter id keine Transaction existiert.
def get(self, id):
"""Auslesen des Kontostands bzw. des Saldos eines bestimmten Account-Objekts.
Das Account-Objekt dessen Saldo wir auslesen möchten, wird durch die ```id``` in dem URI bestimmt.
"""
adm = BankAdministration()
# Zunächst benötigen wir das durch id gegebene Konto.
acc = adm.get_account_by_id(id)
# Haben wir eine brauchbare Referenz auf ein Account-Objekt bekommen?
if acc is not None:
# Jetzt erst lesen wir den Saldo des Kontos aus.
balance = adm.get_balance_of_account(acc)
return balance
else:
return 0, 500
def get(self, id):
"""Auslesen aller Acount-Objekte bzgl. eines bestimmten Customer-Objekts.
Das Customer-Objekt dessen Accounts wir lesen möchten, wird durch die ```id``` in dem URI bestimmt.
"""
adm = BankAdministration()
# Zunächst benötigen wir den durch id gegebenen Customer.
cust = adm.get_customer_by_id(id)
# Haben wir eine brauchbare Referenz auf ein Customer-Objekt bekommen?
if cust is not None:
# Jetzt erst lesen wir die Konten des Customer aus.
account_list = adm.get_accounts_of_customer(cust)
return account_list
else:
return "Customer not found", 500
def post(self, id):
"""Anlegen eines Kontos für einen gegebenen Customer.
Das neu angelegte Konto wird als Ergebnis zurückgegeben.
**Hinweis:** Unter der id muss ein Customer existieren, andernfalls wird Status Code 500 ausgegeben."""
adm = BankAdministration()
"""Stelle fest, ob es unter der id einen Customer gibt.
Dies ist aus Gründen der referentiellen Integrität sinnvoll!
"""
cust = adm.get_customer_by_id(id)
if cust is not None:
# Jetzt erst macht es Sinn, für den Customer ein neues Konto anzulegen und dieses zurückzugeben.
result = adm.create_account_for_customer(cust)
return result
else:
return "Customer unknown", 500
def post(self, id):
"""Anlegen einer Gruppe für einer gegebenen Person.
Die neu angelegte Gruppe wird als Ergebnis zurückgegeben.
**Hinweis:** Unter der id muss ein Customer existieren, andernfalls wird Status Code 500 ausgegeben."""
grp = BankAdministration()
"""Stelle fest, ob es unter der id einen Customer gibt.
Dies ist aus Gründen der referentiellen Integrität sinnvoll!
"""
cust = grp.get_person_by_id(id)
if cust is not None:
result = grp.create_group_for_person(cust)
return result
else:
return "Person unknown", 500
def get(self, id):
"""Auslesen aller Guthabenbuchungen bzgl. eines bestimmten Account-Objekts.
**HINWEISE:** Credits sind Guthabenbuchungen, also Transaction-Objekte, die den Kontostand *positiv erhöhen*.
Man könnte sie auch als Habenbuchungen auffassen (vgl. Rechnungswesen).
Das Account-Objekt dessen Guthabenbuchungen wir auslesen möchten, wird durch die ```id``` in dem URI bestimmt.
"""
adm = BankAdministration()
# Zunächst benötigen wir das durch id gegebene Account-Objekt.
acc = adm.get_account_by_id(id)
# Haben wir eine brauchbare Referenz auf ein Customer-Objekt bekommen?
if acc is not None:
# Jetzt erst lesen wir die Konten des Customer aus.
credits = adm.get_credits_of_account(acc)
return credits
else:
return "Account not found", 500
def put(self, id):
"""Update eines bestimmten Transaction-Objekts.
**ACHTUNG:** Relevante id ist die id, die mittels URI bereitgestellt und somit als Methodenparameter
verwendet wird. Dieser Parameter überschreibt das ID-Attribut des im Payload der Anfrage übermittelten
Customer-Objekts.
"""
adm = BankAdministration()
t = Transaction.from_dict(api.payload)
if t is not None:
"""Hierdurch wird die id des zu überschreibenden (vgl. Update) Transaction-Objekts gesetzt.
Siehe Hinweise oben.
"""
t.set_id(id)
adm.save_transaction(t)
return '', 200
else:
return '', 500
def post(self):
"""Anlegen eines neuen Customer-Objekts.
**ACHTUNG:** Wir fassen die vom Client gesendeten Daten als Vorschlag auf.
So ist zum Beispiel die Vergabe der ID nicht Aufgabe des Clients.
Selbst wenn der Client eine ID in dem Proposal vergeben sollte, so
liegt es an der BankAdministration (Businesslogik), eine korrekte ID
zu vergeben. *Das korrigierte Objekt wird schließlich zurückgegeben.*
"""
adm = BankAdministration()
proposal = Customer.from_dict(api.payload)
"""RATSCHLAG: Prüfen Sie stets die Referenzen auf valide Werte, bevor Sie diese verwenden!"""
if proposal is not None:
""" Wir verwenden lediglich Vor- und Nachnamen des Proposals für die Erzeugung
eines Customer-Objekts. Das serverseitig erzeugte Objekt ist das maßgebliche und
wird auch dem Client zurückgegeben.
"""
c = adm.create_customer(proposal.get_first_name(), proposal.get_last_name())
return c, 200
else:
# Wenn irgendetwas schiefgeht, dann geben wir nichts zurück und werfen einen Server-Fehler.
return '', 500
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 = BankAdministration()
google_user_id = claims.get("user_id")
email = claims.get("email")
name = claims.get("name")
user = adm.get_user_by_google_user_id(google_user_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_user_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 !!!