741 lines
34 KiB
Python
741 lines
34 KiB
Python
from flask import Flask, render_template, request, flash, redirect, session, send_file
|
|
from werkzeug.utils import secure_filename
|
|
from flask_wtf import FlaskForm
|
|
from wtforms.fields.html5 import DateField, EmailField
|
|
from wtforms.fields import StringField, BooleanField
|
|
from wtforms.validators import DataRequired, ValidationError, EqualTo
|
|
from flask_sqlalchemy import SQLAlchemy
|
|
from flask_security import Security, SQLAlchemyUserDatastore, auth_required, hash_password, uia_email_mapper, \
|
|
current_user, roles_required
|
|
from flask_security.models import fsqla_v2 as fsqla
|
|
from flask_security.forms import LoginForm, Required, PasswordField
|
|
from flask_security.utils import find_user
|
|
from flask_security.views import change_password
|
|
from flask_mail import Mail
|
|
from email_validator import validate_email
|
|
|
|
import json
|
|
import secrets
|
|
import bleach
|
|
import ldap3
|
|
from ldap3.core.exceptions import LDAPBindError, LDAPSocketOpenError
|
|
from pathlib import Path
|
|
import logging
|
|
import tempfile
|
|
|
|
from datetime import date
|
|
from .door_handle import DoorHandle
|
|
|
|
|
|
def validate_valid_thru_date(form, field):
|
|
if form.limit_validity.data: # only check date format if limited validity of token is set
|
|
try:
|
|
if not field.data >= date.today():
|
|
raise ValueError
|
|
except ValueError as e:
|
|
flash("Ungültiges Datum")
|
|
raise ValidationError
|
|
return True
|
|
|
|
|
|
class TokenForm(FlaskForm):
|
|
name = StringField('Name', validators=[DataRequired()])
|
|
email = EmailField('E-Mail', validators=[DataRequired()])
|
|
organization = StringField('Organization', validators=[DataRequired()])
|
|
limit_validity = BooleanField('Gültigkeit begrenzen?')
|
|
valid_thru = DateField('Gültig bis', validators=[validate_valid_thru_date])
|
|
active = BooleanField('Aktiv?')
|
|
dsgvo = BooleanField('Einwilligung Nutzungsbedingungen erfragt?', validators=[DataRequired()])
|
|
|
|
|
|
class ConfirmDeleteForm(FlaskForm):
|
|
name = StringField('Name', validators=[DataRequired(), EqualTo('name_confirm', 'Name stimmt nicht überein')])
|
|
name_confirm = StringField('Name confirm')
|
|
|
|
|
|
class AdminCreationForm(FlaskForm):
|
|
name = StringField('Name', validators=[DataRequired()])
|
|
email = EmailField('E-Mail', validators=[DataRequired()])
|
|
|
|
|
|
def uia_username_mapper(identity):
|
|
# we allow pretty much anything - but we bleach it.
|
|
return bleach.clean(identity, strip=True)
|
|
|
|
|
|
def create_application(config):
|
|
# set up logging for the web app
|
|
logger = logging.getLogger('webapp')
|
|
logger.setLevel(logging.INFO)
|
|
|
|
if config.log_file is not None:
|
|
ch = logging.FileHandler(config.log_file)
|
|
ch.setLevel(logging.INFO)
|
|
else:
|
|
# create console handler and set level to debug
|
|
ch = logging.StreamHandler()
|
|
ch.setLevel(logging.DEBUG)
|
|
# create formatter
|
|
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
|
|
# add formatter to ch
|
|
ch.setFormatter(formatter)
|
|
# add ch to logger
|
|
logger.addHandler(ch)
|
|
|
|
# do some checks for file existence etc.
|
|
try:
|
|
with open(config.key_file) as f:
|
|
data = f.readlines()
|
|
if 'SECRET_KEY' in data[0]:
|
|
secret_key = data[0].split()[-1]
|
|
else:
|
|
raise Exception("Could not read SECURITY_PASSWORD_SALT")
|
|
if 'SECURITY_PASSWORD_SALT' in data[1]:
|
|
security_password_salt = data[1].split()[-1]
|
|
else:
|
|
raise Exception("Could not read SECURITY_PASSWORD_SALT")
|
|
except Exception as e:
|
|
logger.warning(f"Flask keys could not be read from file at {Path(config.key_file).absolute()}. Exception: {e}. Using default values instead.")
|
|
secret_key = 'Q7PJu2fg2jabYwP-Psop6c6f2G4'
|
|
security_password_salt = '10036796768252925167749545152988277953'
|
|
|
|
if Path(config.template_folder).is_absolute():
|
|
if not Path(config.template_folder).exists():
|
|
logger.error(f'Flask template folder not found at {Path(config.template_folder).absolute()}')
|
|
else:
|
|
if not (Path(__file__).parent / config.template_folder).exists():
|
|
logger.error(f'Flask template folder not found at {(Path(__file__).parent / config.template_folder).absolute()}')
|
|
if Path(config.static_folder).is_absolute():
|
|
if not Path(config.static_folder).exists():
|
|
logger.error(f'Flask static folder not found at {Path(config.static_folder).absolute()}')
|
|
else:
|
|
if not (Path(__file__).parent / config.static_folder).exists():
|
|
logger.error(f'Flask static folder not found at {(Path(__file__).parent / config.static_folder).absolute()}')
|
|
if not Path(config.token_file).exists():
|
|
logger.warning(f"Token file not found at {Path(config.token_file).absolute()}")
|
|
|
|
# create door objects which provides access to the token file and current door state via MQTT
|
|
door = DoorHandle(token_file=config.token_file, mqtt_host=config.mqtt_host, nfc_socket=config.nfc_socket,
|
|
logger=logger)
|
|
|
|
app = Flask(__name__, template_folder=config.template_folder, static_folder=config.static_folder)
|
|
|
|
# Generate a nice key using secrets.token_urlsafe()
|
|
app.config['SECRET_KEY'] = secret_key
|
|
# Bcrypt is set as default SECURITY_PASSWORD_HASH, which requires a salt
|
|
# Generate a good salt using: secrets.SystemRandom().getrandbits(128)
|
|
app.config['SECURITY_PASSWORD_SALT'] = security_password_salt
|
|
|
|
app.config['SECURITY_USER_IDENTITY_ATTRIBUTES'] = [
|
|
{"email": {"mapper": uia_email_mapper, "case_insensitive": True}},
|
|
{"username": {"mapper": uia_username_mapper}}
|
|
]
|
|
app.config['SECURITY_CHANGEABLE'] = True
|
|
app.config['SECURITY_RECOVERABLE'] = True
|
|
app.config['SECURITY_SEND_PASSWORD_CHANGE_EMAIL'] = False
|
|
|
|
# Mail Config
|
|
app.config['MAIL_SERVER'] = config.mail_server
|
|
app.config['MAIL_PORT'] = config.mail_port
|
|
app.config['MAIL_USE_TLS'] = config.mail_use_tls
|
|
app.config['MAIL_USE_SSL'] = config.mail_use_ssl
|
|
app.config['MAIL_USERNAME'] = config.mail_username
|
|
app.config['MAIL_PASSWORD'] = config.mail_password
|
|
app.config['MAIL_DEFAULT_SENDER'] = app.config['MAIL_USERNAME']
|
|
mail = Mail(app)
|
|
|
|
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///admin.db'
|
|
# As of Flask-SQLAlchemy 2.4.0 it is easy to pass in options directly to the
|
|
# underlying engine. This option makes sure that DB connections from the
|
|
# pool are still valid. Important for entire application since
|
|
# many DBaaS options automatically close idle connections.
|
|
app.config["SQLALCHEMY_ENGINE_OPTIONS"] = {
|
|
"pool_pre_ping": True,
|
|
}
|
|
|
|
# Create database connection object
|
|
db = SQLAlchemy(app)
|
|
|
|
# Define models
|
|
fsqla.FsModels.set_db_info(db)
|
|
|
|
class Role(db.Model, fsqla.FsRoleMixin):
|
|
pass
|
|
|
|
class User(db.Model, fsqla.FsUserMixin):
|
|
pass
|
|
|
|
# LDAP
|
|
ldap_server = ldap3.Server(config.ldap_url)
|
|
|
|
def validate_ldap(username, password):
|
|
"""Validate the user and password through an LDAP server.
|
|
|
|
If the connection completes successfully the given user and password is authorized.
|
|
Then the permissions and additional information of the user are obtained through an LDAP search.
|
|
The data is stored in a dict which will be used later to create/update the entry for the user in the local
|
|
database.
|
|
|
|
Parameters
|
|
----------
|
|
username : username for the LDAP server
|
|
password : password for the LDAP server
|
|
|
|
Returns
|
|
-------
|
|
bool : result of the authorization process (True = success, False = failure)
|
|
dict : dictionary with information about an authorized user (contains username, email, hashed password,
|
|
roles)
|
|
"""
|
|
|
|
try:
|
|
con = ldap3.Connection(ldap_server, user=f"uid={username},ou=Users,dc=imaginaerraum,dc=de",
|
|
password=password, auto_bind=True)
|
|
except ldap3.core.exceptions.LDAPBindError:
|
|
# server reachable but user unauthorized -> fail
|
|
return False, None
|
|
except LDAPSocketOpenError:
|
|
# server not reachable -> fail (but will try authorization from local database later)
|
|
return False, None
|
|
except Exception as e:
|
|
# for other Exceptions we just fail
|
|
return False, None
|
|
|
|
# get user data and permissions from LDAP server
|
|
new_user_data = {}
|
|
new_user_data['username'] = username
|
|
new_user_data['password'] = hash_password(password)
|
|
new_user_data['roles'] = []
|
|
lock_permission = con.search('ou=Users,dc=imaginaerraum,dc=de',
|
|
f'(&(uid={username})(memberof=cn=Members,ou=Groups,dc=imaginaerraum,dc=de))',
|
|
attributes=ldap3.ALL_ATTRIBUTES)
|
|
if lock_permission:
|
|
new_user_data['email'] = con.entries[0].mail.value
|
|
else:
|
|
new_user_data['email'] = None
|
|
token_granting_permission = con.search('ou=Users,dc=imaginaerraum,dc=de',
|
|
f'(&(uid={username})(memberof=cn=Vorstand,ou=Groups,dc=imaginaerraum,dc=de))')
|
|
if token_granting_permission:
|
|
new_user_data['roles'].append('admin')
|
|
|
|
return True, new_user_data
|
|
|
|
class ExtendedLoginForm(LoginForm):
|
|
email = StringField('Benutzername oder E-Mail', [Required()])
|
|
password = PasswordField('Passwort', [Required()])
|
|
remember = BooleanField('Login merken?')
|
|
|
|
def validate(self):
|
|
# search for user in the current database
|
|
user = find_user(self.email.data)
|
|
if user is not None:
|
|
# if a user is found we check if it is associated with LDAP or with the local database
|
|
if user.has_role('local'):
|
|
# try authorizing locally using Flask security user datastore
|
|
authorized = super(ExtendedLoginForm, self).validate()
|
|
|
|
if authorized:
|
|
logger.info(f"User with credentials '{self.email.data}' authorized through local database")
|
|
else:
|
|
# run LDAP authorization
|
|
# if the authorization succeeds we also get the new_user_data dict which contains information about
|
|
# the user's permissions etc.
|
|
authorized, new_user_data = validate_ldap(user.username, self.password.data)
|
|
|
|
if authorized:
|
|
logger.info(f"User with credentials '{self.email.data}' authorized through LDAP")
|
|
# update permissions and password/email to stay up to date for login with no network connection
|
|
user.email = new_user_data['email']
|
|
user.password = new_user_data['password']
|
|
for role in new_user_data['roles']:
|
|
user_datastore.add_role_to_user(user, role)
|
|
user_datastore.commit()
|
|
self.user = user
|
|
else:
|
|
self.password.errors = ['Invalid password']
|
|
else:
|
|
# this means there is no user with that email in the database
|
|
# we assume that the username was entered instead of an email and use that for authentication with LDAP
|
|
username = self.email.data
|
|
# try LDAP authorization and create a new user if it succeeds
|
|
authorized, new_user_data = validate_ldap(username, self.password.data)
|
|
|
|
if authorized:
|
|
# if there was no user in the database before we create a new user
|
|
self.user = user_datastore.create_user(username=new_user_data['username'], email=new_user_data['email'],
|
|
password=new_user_data['password'], roles=new_user_data['roles'])
|
|
user_datastore.commit()
|
|
logger.info(f"New admin user '{new_user_data['username']} <{new_user_data['email']}>' created after"
|
|
" successful LDAP authorization")
|
|
|
|
# if any of the authorization methods is successful we authorize the user
|
|
return authorized
|
|
|
|
# we override the change_password view from flask security to only allow local users to change their passwords
|
|
# LDAP users should use the LDAP self service for changing passwords
|
|
# this route needs to be defined before the Flask Security setup
|
|
@app.route('/change', methods=['GET', 'POST'])
|
|
@auth_required()
|
|
def change_pw():
|
|
if current_user.has_role('local'):
|
|
# local users can change their password
|
|
return change_password()
|
|
else:
|
|
# LDAP users get redirected to the LDAP self service
|
|
return redirect('https://ldap.imaginaerraum.de/')
|
|
|
|
# Setup Flask-Security
|
|
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
|
|
security = Security(app, user_datastore, login_form=ExtendedLoginForm)
|
|
|
|
# admin user management
|
|
@app.route('/manage_admins', methods=['GET', 'POST'])
|
|
@roles_required('super_admin')
|
|
def manage_admins():
|
|
form = AdminCreationForm()
|
|
if request.method == 'GET':
|
|
users = user_datastore.user_model.query.all()
|
|
admin_data = [{'username': u.username, 'email': u.email, 'active': u.is_active,
|
|
'admin': u.has_role('admin'), 'super_admin': u.has_role('super_admin'),
|
|
} for u in users]
|
|
return render_template('admins.html', admin_data=admin_data, form=form)
|
|
elif form.validate():
|
|
if user_datastore.find_user(username=form.name.data) is not None or \
|
|
user_datastore.find_user(email=form.email.data) is not None:
|
|
flash("Ein Benutzer mit diesem Nutzernamen oder dieser E-Mail-Adresse existiert bereits!")
|
|
return redirect('/manage_admins')
|
|
else:
|
|
pw = secrets.token_urlsafe(16)
|
|
new_user = user_datastore.create_user(username=form.name.data, email=form.email.data,
|
|
password=hash_password(pw))
|
|
user_datastore.add_role_to_user(new_user, 'local')
|
|
logger.info(
|
|
f"Super admin {current_user.username} created new user account for {new_user.username} <{new_user.email}>")
|
|
flash(f"Ein Account für den Nutzer {new_user.username} wurde erstellt. Verwende das Passwort {pw} um den Nutzer einzuloggen.")
|
|
db.session.commit()
|
|
return redirect('/manage_admins')
|
|
|
|
@app.route('/delete_admins/<username>', methods=['GET', 'POST'])
|
|
@roles_required('super_admin')
|
|
def delete_admins(username):
|
|
user = user_datastore.find_user(username=username)
|
|
if user is None:
|
|
flash(f"Ungültiger Nutzer {username}")
|
|
return redirect('/manage_admins')
|
|
if user.has_role('super_admin'):
|
|
flash('Super-Admins können nicht gelöscht werden!')
|
|
return redirect('/manage_admins')
|
|
if user.is_active:
|
|
flash('Aktive Nutzer können nicht gelöscht werden! Bitte den Benutzer zuerst deaktivieren.')
|
|
return redirect('/manage_admins')
|
|
|
|
# set up form for confirming deletion
|
|
form = ConfirmDeleteForm()
|
|
form.name_confirm.data = username
|
|
|
|
if request.method == 'GET':
|
|
# return page asking the user to confirm delete
|
|
return render_template('delete_user.html', username=username, form=form)
|
|
elif form.validate():
|
|
user_datastore.delete_user(user)
|
|
flash(f"Benutzer {username} wurde gelöscht.")
|
|
logger.info(f"Super admin {current_user.username} deleted admin user {username}")
|
|
db.session.commit()
|
|
return redirect('/manage_admins')
|
|
else:
|
|
flash("Der eingegebene Nutzername stimmt nicht überein. Der Benutzer wurde nicht gelöscht!")
|
|
return redirect('/manage_admins')
|
|
|
|
@app.route('/admin_toggle_active/<username>')
|
|
@roles_required('super_admin')
|
|
def admin_toggle_active(username):
|
|
user = user_datastore.find_user(username=username)
|
|
if user is None:
|
|
flash(f"Ungültiger Nutzer {username}")
|
|
return redirect('/manage_admins')
|
|
if user.has_role('super_admin'):
|
|
flash('Super-Admins können nicht deaktiviert werden!')
|
|
return redirect('/manage_admins')
|
|
user_datastore.toggle_active(user)
|
|
if user.is_active:
|
|
logger.info(f"Super admin {current_user.username} activated access for admin user {username}")
|
|
else:
|
|
logger.info(f"Super admin {current_user.username} deactivated access for admin user {username}")
|
|
db.session.commit()
|
|
return redirect('/manage_admins')
|
|
|
|
@app.route('/promote_admin/<username>')
|
|
@roles_required('super_admin')
|
|
def promote_admin(username):
|
|
user = user_datastore.find_user(username=username)
|
|
if user is None:
|
|
flash(f"Ungültiger Nutzer {username}")
|
|
return redirect('/manage_admins')
|
|
if user.has_role('admin'):
|
|
flash(f'Benutzer {username} hat bereits Admin-Rechte!')
|
|
return redirect('/manage_admins')
|
|
user_datastore.add_role_to_user(user, 'admin')
|
|
logger.info(f"Super admin {current_user.username} granted admin privileges to user {username}")
|
|
db.session.commit()
|
|
return redirect('/manage_admins')
|
|
|
|
@app.route('/demote_admin/<username>')
|
|
@roles_required('super_admin')
|
|
def demote_admin(username):
|
|
user = user_datastore.find_user(username=username)
|
|
if user is None:
|
|
flash(f"Ungültiger Nutzer {username}")
|
|
return redirect('/manage_admins')
|
|
if user.has_role('super_admin'):
|
|
flash(f'Benutzer {username} hat Super-Admin-Rechte und kann nicht verändert werden!')
|
|
return redirect('/manage_admins')
|
|
if user.has_role('admin'):
|
|
user_datastore.remove_role_from_user(user, 'admin')
|
|
logger.info(f"Super admin {current_user.username} revoked admin privileges of user {username}")
|
|
db.session.commit()
|
|
else:
|
|
flash(f'Benutzer {username} ist bereits kein Admin!')
|
|
return redirect('/manage_admins')
|
|
|
|
@app.route('/backup_user_datastore')
|
|
@roles_required('super_admin')
|
|
def backup_user_datastore():
|
|
# get list of defined admin users for backup
|
|
users = user_datastore.user_model.query.all()
|
|
user_data = [{'username': u.username, 'email': u.email, 'active': u.is_active, 'password_hash': u.password,
|
|
'roles': [r.name for r in u.roles]}
|
|
for u in users if not u.has_role('super_admin')]
|
|
try:
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
file = Path(tmpdir, 'user_data.txt')
|
|
file.write_text(json.dumps(user_data))
|
|
return send_file(file, as_attachment=True, cache_timeout=-1)
|
|
except Exception as e:
|
|
return str(e)
|
|
|
|
@app.route('/restore_user_datastore', methods=['POST'])
|
|
@roles_required('super_admin')
|
|
def restore_user_datastore():
|
|
# check if the post request has the file part
|
|
if 'file' not in request.files:
|
|
flash('Keine Datei ausgewählt!')
|
|
return redirect(request.url)
|
|
file = request.files['file']
|
|
# if user does not select file, browser also
|
|
# submit an empty part without filename
|
|
if file.filename == '':
|
|
flash('Keine Datei ausgewählt!')
|
|
return redirect('/manage_admins')
|
|
filename = secure_filename(file.filename)
|
|
if file and filename.endswith('.txt'):
|
|
data = file.stream.read()
|
|
try:
|
|
# check validity of user data
|
|
user_data = json.loads(data)
|
|
valid = type(user_data) == list
|
|
valid &= all(type(d) == dict for d in user_data)
|
|
if valid:
|
|
for d in user_data:
|
|
entry_valid = set(d.keys()) == { 'active', 'email', 'password_hash', 'username', 'roles'}
|
|
entry_valid &= all(len(d[key]) > 0 for key in ['email', 'password_hash', 'username'])
|
|
entry_valid &= type(d['active']) == bool
|
|
entry_valid &= type(d['roles']) == list
|
|
validate_email(d['email'])
|
|
if entry_valid:
|
|
existing_user = user_datastore.find_user(username=d['username'], email=d['email'])
|
|
if existing_user is None:
|
|
user_datastore.create_user(username=d['username'], email=d['email'],
|
|
password=d['password_hash'], active=d['active'],
|
|
roles=d['roles'])
|
|
flash(f"Account für Benutzer '{d['username']} wurde wiederhergestellt.")
|
|
else:
|
|
flash(f"Benutzer '{d['username']} existiert bereits. Eintrag wird übersprungen.")
|
|
else:
|
|
raise ValueError(f"Ungültige Daten für User Entry {d}")
|
|
else:
|
|
raise ValueError("Admin User Datei hat ungültiges Format.")
|
|
except Exception as e:
|
|
flash(f"Die Datei konnte nicht gelesen werden. Exception: {e}")
|
|
return redirect('/manage_admins')
|
|
flash("Benutzer aus Datei gelesen.")
|
|
db.session.commit()
|
|
else:
|
|
flash("Ungültige Dateiendung")
|
|
return redirect('/manage_admins')
|
|
# main page
|
|
@app.route('/')
|
|
def door_lock():
|
|
return render_template('index.html', door_state=door.state, encoder_position=door.encoder_position)
|
|
|
|
# token overview
|
|
@app.route('/tokens')
|
|
@roles_required('admin')
|
|
def list_tokens():
|
|
tokens = door.get_tokens()
|
|
assigned_tokens = {t: data for t, data in tokens.items() if not data['inactive']}
|
|
inactive_tokens = {t: data for t, data in tokens.items() if data['inactive']}
|
|
return render_template('tokens.html', assigned_tokens=assigned_tokens, inactive_tokens=inactive_tokens)
|
|
|
|
@app.route('/token-log')
|
|
@roles_required('super_admin')
|
|
def token_log():
|
|
log = []
|
|
try:
|
|
with open(config.nfc_log) as f:
|
|
log += f.readlines()
|
|
log.reverse()
|
|
log = map(lambda l: l.split(' ', 2), log)
|
|
return render_template('token_log.html', log=log)
|
|
except Exception as e:
|
|
flash(f"NFC logfile {Path(config.nfc_log).absolute()} konnte nicht gelesen werden. Exception: {e}")
|
|
return redirect('/')
|
|
|
|
# routes for registering, editing and deleting tokens
|
|
@app.route('/register-token', methods=['GET', 'POST'])
|
|
@roles_required('admin')
|
|
def register():
|
|
"""Register new token for locking and unlocking the door.
|
|
|
|
This route displays the most recently scanned invalid token as reported in the logfile and provides a form for
|
|
entering user info (name, email, valid thru date (optional)) for the new token.
|
|
|
|
If the route is called via POST the provided form data is checked and if the check succeeds the /store-token route
|
|
will be called which adds the new token to the database.
|
|
"""
|
|
form = TokenForm()
|
|
if request.method == 'GET':
|
|
# set default valid thru date to today to make sure form validity check passes
|
|
# (will not be used if limited validity is disabled)
|
|
form.valid_thru.data = date.today()
|
|
return render_template('register.html', token=door.get_most_recent_token(), form=form)
|
|
elif request.method == 'POST' and form.validate():
|
|
# store data in session cookie
|
|
session['token'] = door.get_most_recent_token()['token']
|
|
session['name'] = form.name.data
|
|
session['email'] = form.email.data
|
|
session['organization'] = form.organization.data
|
|
if form.limit_validity.data:
|
|
session['valid_thru'] = form.valid_thru.data.isoformat()
|
|
else:
|
|
session['valid_thru'] = ''
|
|
session['inactive'] = not form.active.data
|
|
return redirect('/store-token')
|
|
else:
|
|
return render_template('register.html', token=door.get_most_recent_token(), form=form)
|
|
|
|
@app.route('/edit-token/<token>', methods=['GET', 'POST'])
|
|
@roles_required('admin')
|
|
def edit_token(token):
|
|
"""Edit data in the token file (name, email, valid_thru date, active/inactive).
|
|
|
|
If the route is accessed via GET it will provide a form for editing the currently stored data for the user.
|
|
If the route is accessed via POST it will check if the form data is good and then store the modified user data in
|
|
the database (by redirecting to the /store-token route)
|
|
|
|
Parameters
|
|
----------
|
|
token : str
|
|
The token for which data should be edited.
|
|
"""
|
|
form = TokenForm(request.form)
|
|
form.dsgvo.validators = [] # we skip the validation of the DSGVO checkbox here because we assume the user agreed
|
|
# to it before
|
|
if request.method == 'GET':
|
|
tokens = door.get_tokens()
|
|
if token in tokens:
|
|
# set default for form according to values from the token file
|
|
et = tokens[token]
|
|
form.active.data = not et['inactive']
|
|
form.name.data = et['name'] if et['name'] else ''
|
|
form.email.data = et['email'] if et['email'] else ''
|
|
form.organization.data = et['organization'] if et['organization'] else ''
|
|
|
|
# for the valid thru date we use today's date in case there is not valid date in the database
|
|
try:
|
|
form.valid_thru.data = date.fromisoformat(et['valid_thru'])
|
|
form.limit_validity.data = True
|
|
except Exception:
|
|
form.valid_thru.data = date.today()
|
|
|
|
return render_template('edit.html', token=token, form=form)
|
|
else:
|
|
# flash an error message if the route is accessed with an invalid token
|
|
flash(f'Ausgewaehlter Token {token} in Tokenfile nicht gefunden.')
|
|
return redirect('/tokens')
|
|
elif request.method == 'POST':
|
|
if form.validate():
|
|
# store data in session cookie
|
|
session['token'] = token
|
|
session['name'] = form.name.data
|
|
session['organization'] = form.organization.data
|
|
session['email'] = form.email.data
|
|
if form.limit_validity.data:
|
|
session['valid_thru'] = form.valid_thru.data.isoformat()
|
|
else:
|
|
session['valid_thru'] = ''
|
|
session['inactive'] = not form.active.data
|
|
return redirect(f'/store-token')
|
|
else:
|
|
return render_template('edit.html', token=token, form=form)
|
|
|
|
@app.route('/store-token')
|
|
@roles_required('admin')
|
|
def store_token():
|
|
"""Store token to the token file on disk.
|
|
|
|
This will use the token id and the associated data stored in the session cookie (filled by register_token() or
|
|
edit_token()) and create/modify a token and store the new token file to disk.
|
|
"""
|
|
token = session['token']
|
|
tokens = door.get_tokens()
|
|
tokens[token] = {'name': session['name'],
|
|
'email': session['email'],
|
|
'valid_thru': session['valid_thru'],
|
|
'inactive': session['inactive'],
|
|
'organization': session['organization']}
|
|
try:
|
|
door.store_tokens(tokens)
|
|
logger.info(f"Token {token} stored in database by admin user {current_user.username}")
|
|
except Exception as e:
|
|
flash(f"Error during store_tokens. Exception: {e}")
|
|
return redirect('/tokens')
|
|
|
|
@app.route('/delete-token/<token>', methods=['GET', 'POST'])
|
|
@roles_required('admin')
|
|
def delete_token(token):
|
|
"""Delete the given token from the token file and store the new token file to disk
|
|
|
|
Parameters
|
|
----------
|
|
token : str
|
|
The token to delete from the database.
|
|
"""
|
|
tokens = door.get_tokens()
|
|
|
|
if token in tokens:
|
|
token_to_delete = tokens[token]
|
|
|
|
# set up form for confirming deletion
|
|
form = ConfirmDeleteForm()
|
|
form.name_confirm.data = token_to_delete['name']
|
|
|
|
if request.method == 'GET':
|
|
# return page asking the user to confirm delete
|
|
return render_template('delete.html', token=token_to_delete, form=form)
|
|
elif form.validate():
|
|
# form validation successful -> can delete the token
|
|
tokens.pop(token)
|
|
try:
|
|
door.store_tokens(tokens)
|
|
logger.info(f"Token {token} was deleted from database by admin user {current_user.username}")
|
|
except Exception as e:
|
|
flash(f"Error during store_tokens. Exception: {e}")
|
|
flash(f"Token {token} wurde gelöscht!")
|
|
return redirect('/tokens')
|
|
else:
|
|
# form validation failed -> return to token overview and flash message
|
|
flash(
|
|
f"Der eingegebene Name stimmt nicht überein. Der Token {token} von {token_to_delete['name']} wurde nicht gelöscht.")
|
|
return redirect('/tokens')
|
|
else:
|
|
flash(f'Ungültiger Token {token} für Löschung.')
|
|
return redirect('/tokens')
|
|
|
|
@app.route('/deactivate-token/<token>')
|
|
@roles_required('admin')
|
|
def deactivate_token(token):
|
|
"""Deactivate access for the given token. This updates the token file on disk.
|
|
|
|
Parameters
|
|
----------
|
|
token : str
|
|
The token to deactivate.
|
|
"""
|
|
tokens = door.get_tokens()
|
|
if token in tokens:
|
|
tokens[token]['inactive'] = True
|
|
try:
|
|
door.store_tokens(tokens)
|
|
logger.info(f"Token {token} deactivated by admin user {current_user.username}")
|
|
except Exception as e:
|
|
flash(f"Error during store_tokens. Exception: {e}")
|
|
return redirect('/tokens')
|
|
|
|
@app.route('/backup_tokens')
|
|
@roles_required('admin')
|
|
def backup_tokens():
|
|
# get list of defined admin users for backup
|
|
tokens = door.get_tokens()
|
|
try:
|
|
with tempfile.TemporaryDirectory() as tmpdir:
|
|
file = Path(tmpdir, 'token_data.txt')
|
|
file.write_text(json.dumps(tokens))
|
|
return send_file(file, as_attachment=True, cache_timeout=-1)
|
|
except Exception as e:
|
|
return str(e)
|
|
|
|
@app.route('/open')
|
|
@auth_required()
|
|
def open_door():
|
|
try:
|
|
door.open_door()
|
|
logger.info(f"Door opened by admin user {current_user.username}")
|
|
except Exception as e:
|
|
flash(f'Could not open door. Exception: {e}')
|
|
return redirect('/')
|
|
|
|
# routes for opening and closing the door via the web interface
|
|
@app.route('/close')
|
|
@auth_required()
|
|
def close_door():
|
|
try:
|
|
door.close_door()
|
|
logger.info(f"Door closed by admin user {current_user.username}")
|
|
except Exception as e:
|
|
flash(f'Could not close door. Exception: {e}')
|
|
return redirect('/')
|
|
|
|
# setup user database when starting the app
|
|
with app.app_context():
|
|
new_admin_data = []
|
|
if config.admin_file is not None:
|
|
if not Path(config.admin_file).exists():
|
|
logger.warning(f"Admin user creation file not found at {config.admin_file}")
|
|
else:
|
|
# store data for new admins in memory s.t. the file can be deleted afterwards
|
|
with open(config.admin_file) as f:
|
|
for i, line in enumerate(f.readlines()):
|
|
if not line.strip().startswith('#'):
|
|
try:
|
|
user, email, pw = line.split()
|
|
validate_email(email)
|
|
new_admin_data.append({'username': user, 'email': email, 'password': pw})
|
|
except Exception as e:
|
|
print(
|
|
f"Error while parsing line {i} in admin config file. Config file should contain lines of "
|
|
f"'<username> <email> <password>\\n'\n Exception: {e}\nAdmin account could not be created.")
|
|
|
|
# create admin users (only if they don't exists already)
|
|
def create_super_admins(new_admin_data):
|
|
db.create_all()
|
|
super_admin_role = user_datastore.find_or_create_role('super_admin') # root admin = can create other admins
|
|
admin_role = user_datastore.find_or_create_role('admin') # 'normal' admin
|
|
local_role = user_datastore.find_or_create_role('local') # LDAP user or local user
|
|
|
|
for d in new_admin_data:
|
|
if user_datastore.find_user(email=d['email'], username=d['username']) is None:
|
|
roles = [super_admin_role, admin_role]
|
|
if not d['password'] == 'LDAP':
|
|
roles.append(local_role)
|
|
logger.info(f"New super admin user created with username '{d['username']}' and email '{d['email']}', roles = {[r.name for r in roles]}")
|
|
|
|
# create new admin (only if admin does not already exist)
|
|
new_admin = user_datastore.create_user(email=d['email'], username=d['username'],
|
|
password=hash_password(d['password']),
|
|
roles=roles)
|
|
db.session.commit()
|
|
|
|
create_super_admins(new_admin_data)
|
|
|
|
return app
|