async def add_new_user(request):
"""Creates a new user and redirects to the user-edit page."""
try:
users.read_users()
except:
return PlainTextResponse(
'Configuration is being updated. Try again in a minute.')
form = dict(await request.form())
newuser = form.get("name", "")
if newuser in users.users_list:
return PlainTextResponse('User already exists.')
newpassword = users.hash_password(
form.get("password", "here_should_be_a_password"))
users.users_list[newuser] = {
"password": newpassword,
"is_admin": "False",
"change_password": "******"
}
try:
users.save_users()
except:
return PlainTextResponse(
'ERROR: Unable to write user list. Try again.')
logger.info(f'Created user {newuser}')
monitor.send_webgui_event(monitor.w_events.USER_CREATE,
request.user.display_name, newuser)
return RedirectResponse(url='/users/edit/' + newuser, status_code=303)
async def add_target(request):
"""Creates a new target."""
try:
config.read_config()
except:
return PlainTextResponse(
'Configuration is being updated. Try again in a minute.')
form = dict(await request.form())
newtarget = form.get("name", "")
if newtarget in config.mercure["targets"]:
return PlainTextResponse('Target already exists.')
config.mercure["targets"][newtarget] = {"ip": "", "port": ""}
try:
config.save_config()
except:
return PlainTextResponse(
'ERROR: Unable to write configuration. Try again.')
logger.info(f'Created target {newtarget}')
monitor.send_webgui_event(monitor.w_events.TARGET_CREATE,
request.user.display_name, newtarget)
return RedirectResponse(url='/targets/edit/' + newtarget, status_code=303)
async def targes_edit_post(request):
"""Updates the given target using the form values posted with the request."""
try:
config.read_config()
except:
return PlainTextResponse(
'Configuration is being updated. Try again in a minute.')
edittarget = request.path_params["target"]
form = dict(await request.form())
if not edittarget in config.mercure["targets"]:
return PlainTextResponse('Target does not exist anymore.')
config.mercure["targets"][edittarget]["ip"] = form["ip"]
config.mercure["targets"][edittarget]["port"] = form["port"]
config.mercure["targets"][edittarget]["aet_target"] = form["aet_target"]
config.mercure["targets"][edittarget]["aet_source"] = form["aet_source"]
config.mercure["targets"][edittarget]["contact"] = form["contact"]
try:
config.save_config()
except:
return PlainTextResponse(
'ERROR: Unable to write configuration. Try again.')
logger.info(f'Edited target {edittarget}')
monitor.send_webgui_event(monitor.w_events.TARGET_EDIT,
request.user.display_name, edittarget)
return RedirectResponse(url='/targets', status_code=303)
async def control_services(request):
form = dict(await request.form())
action = ''
if form.get('action', '') == 'start':
action = 'start'
if form.get('action', '') == 'stop':
action = 'stop'
if form.get('action', '') == 'restart':
action = 'restart'
if form.get('action', '') == 'kill':
action = 'kill'
controlservices = form.get('services', '').split(",")
if action and len(controlservices) > 0:
for service in controlservices:
if not str(service) in services.services_list:
continue
command = "systemctl " + action + " " + services.services_list[
service]["systemd_service"]
logger.info(f'Executing: {command}')
await async_run(command)
monitor_string = "action: " + action + "; services: " + form.get(
'services', '')
monitor.send_webgui_event(monitor.w_events.SERVICE_CONTROL,
request.user.display_name, monitor_string)
return JSONResponse("{ }")
async def add_rule(request):
"""Creates a new routing rule and forwards the user to the rule edit page."""
try:
config.read_config()
except:
return PlainTextResponse(
'Configuration is being updated. Try again in a minute.')
form = dict(await request.form())
newrule = form.get("name", "")
if newrule in config.mercure["rules"]:
return PlainTextResponse('Rule already exists.')
config.mercure["rules"][newrule] = {"rule": "False"}
try:
config.save_config()
except:
return PlainTextResponse(
'ERROR: Unable to write configuration. Try again.')
logger.info(f'Created rule {newrule}')
monitor.send_webgui_event(monitor.w_events.RULE_CREATE,
request.user.display_name, newrule)
return RedirectResponse(url='/rules/edit/' + newrule, status_code=303)
async def login_post(request):
"""Evaluate the submitted login information. Redirects to index page if login information valid, otherwise back to login.
On the first login, the user will be directed to the settings page and asked to change the password."""
try:
users.read_users()
except:
return PlainTextResponse("Configuration is being updated. Try again in a minute.")
form = dict(await request.form())
if users.evaluate_password(form.get("username", ""), form.get("password", "")):
request.session.update({"user": form["username"]})
if users.is_admin(form["username"]) == True:
request.session.update({"is_admin": "Jawohl"})
monitor.send_webgui_event(monitor.w_events.LOGIN, form["username"], "{admin}".format(admin="ADMIN" if users.is_admin(form["username"]) else ""))
if users.needs_change_password(form["username"]):
return RedirectResponse(url="/settings", status_code=303)
else:
return RedirectResponse(url="/", status_code=303)
else:
if request.client.host is None:
source_ip = "UNKOWN IP"
else:
source_ip = request.client.host
monitor.send_webgui_event(monitor.w_events.LOGIN_FAIL, form["username"], source_ip)
template = "login.html"
context = {"request": request, "invalid_password": 1, "mercure_version": mercure_defs.VERSION, "appliance_name": config.mercure.get("appliance_name", "mercure Router")}
return templates.TemplateResponse(template, context)
async def rules_edit_post(request):
"""Updates the settings for the given routing rule."""
try:
config.read_config()
except:
return PlainTextResponse(
"Configuration is being updated. Try again in a minute.")
editrule = request.path_params["rule"]
form = dict(await request.form())
if not editrule in config.mercure["rules"]:
return PlainTextResponse("Rule does not exist anymore.")
config.mercure["rules"][editrule]["rule"] = form.get("rule", "False")
config.mercure["rules"][editrule]["target"] = form.get("target", "")
config.mercure["rules"][editrule]["disabled"] = form.get(
"status_disabled", "False")
config.mercure["rules"][editrule]["fallback"] = form.get(
"status_fallback", "False")
config.mercure["rules"][editrule]["contact"] = form.get("contact", "")
config.mercure["rules"][editrule]["comment"] = form.get("comment", "")
config.mercure["rules"][editrule]["tags"] = form.get("tags", "")
config.mercure["rules"][editrule]["action"] = form.get("action", "route")
config.mercure["rules"][editrule]["action_trigger"] = form.get(
"action_trigger", "series")
config.mercure["rules"][editrule]["study_trigger_condition"] = form.get(
"study_trigger_condition", "timeout")
config.mercure["rules"][editrule]["study_trigger_series"] = form.get(
"study_trigger_series", "")
config.mercure["rules"][editrule]["priority"] = form.get(
"priority", "normal")
config.mercure["rules"][editrule]["processing_module"] = form.get(
"processing_module", "")
config.mercure["rules"][editrule]["processing_settings"] = form.get(
"processing_settings", "")
config.mercure["rules"][editrule]["notification_webhook"] = form.get(
"notification_webhook", "")
config.mercure["rules"][editrule]["notification_payload"] = form.get(
"notification_payload", "")
config.mercure["rules"][editrule][
"notification_trigger_reception"] = form.get(
"notification_trigger_reception", "False")
config.mercure["rules"][editrule][
"notification_trigger_completion"] = form.get(
"notification_trigger_completion", "False")
config.mercure["rules"][editrule]["notification_trigger_error"] = form.get(
"notification_trigger_error", "False")
try:
config.save_config()
except:
return PlainTextResponse(
"ERROR: Unable to write configuration. Try again.")
logger.info(f"Edited rule {editrule}")
monitor.send_webgui_event(monitor.w_events.RULE_EDIT,
request.user.display_name, editrule)
return RedirectResponse(url="/rules", status_code=303)
async def control_services(request):
form = dict(await request.form())
action = ""
if form.get("action", "") == "start":
action = "start"
if form.get("action", "") == "stop":
action = "stop"
if form.get("action", "") == "restart":
action = "restart"
if form.get("action", "") == "kill":
action = "kill"
controlservices = form.get("services", "").split(",")
if action and len(controlservices) > 0:
for service in controlservices:
if not str(service) in services.services_list:
continue
if services.services_list[service].get("systemd_service", ""):
command = "systemctl " + action + " " + services.services_list[
service]["systemd_service"]
logger.info(f"Executing: {command}")
await async_run(command)
elif services.services_list[service].get("docker_service", ""):
client = docker.from_env()
logger.info(
f'Executing: {action} on {services.services_list[service]["docker_service"]}'
)
try:
container = client.containers.get(
services.services_list[service]["docker_service"])
container.reload()
if action == "start":
container.start()
if action == "stop":
container.stop()
if action == "restart":
container.restart()
if action == "kill":
container.kill()
except (docker.errors.NotFound,
docker.errors.APIError) as docker_error:
logger.error(f"{docker_error}")
pass
monitor_string = "action: " + action + "; services: " + form.get(
"services", "")
monitor.send_webgui_event(monitor.w_events.SERVICE_CONTROL,
request.user.display_name, monitor_string)
return JSONResponse("{ }")
async def configuration_edit_post(request):
"""Updates the configuration after post from editor"""
form = dict(await request.form())
editor_json = form.get("editor", "{}")
try:
validated_json = json.loads(editor_json)
except ValueError:
return PlainTextResponse("Invalid JSON data transferred.")
try:
config.write_configfile(validated_json)
config.read_config()
except ValueError:
return PlainTextResponse("Unable to write config file. Might be locked.")
logger.info(f"Updates mercure configuration file.")
monitor.send_webgui_event(monitor.w_events.CONFIG_EDIT, request.user.display_name, "")
return RedirectResponse(url="/configuration?edited=1", status_code=303)
async def users_delete_post(request):
"""Deletes the given users."""
try:
config.read_config()
except:
return PlainTextResponse("Configuration is being updated. Try again in a minute.")
deleteuser = request.path_params["user"]
if deleteuser in users.users_list:
del users.users_list[deleteuser]
try:
users.save_users()
except:
return PlainTextResponse("ERROR: Unable to write user list. Try again.")
logger.info(f"Deleted user {deleteuser}")
monitor.send_webgui_event(monitor.w_events.USER_DELETE, request.user.display_name, deleteuser)
return RedirectResponse(url="/users", status_code=303)
async def targets_delete_post(request):
"""Deletes the given target."""
try:
config.read_config()
except:
return PlainTextResponse("Configuration is being updated. Try again in a minute.")
deletetarget = request.path_params["target"]
if deletetarget in config.mercure["targets"]:
del config.mercure["targets"][deletetarget]
try:
config.save_config()
except:
return PlainTextResponse("ERROR: Unable to write configuration. Try again.")
logger.info(f"Deleted target {deletetarget}")
monitor.send_webgui_event(monitor.w_events.TARGET_DELETE, request.user.display_name, deletetarget)
return RedirectResponse(url="/targets", status_code=303)
async def rules_delete_post(request):
"""Deletes the given routing rule"""
try:
config.read_config()
except:
return PlainTextResponse("Configuration is being updated. Try again in a minute.")
deleterule = request.path_params["rule"]
if deleterule in config.mercure["rules"]:
del config.mercure["rules"][deleterule]
try:
config.save_config()
except:
return PlainTextResponse("ERROR: Unable to write configuration. Try again.")
logger.info(f"Deleted rule {deleterule}")
monitor.send_webgui_event(monitor.w_events.RULE_DELETE, request.user.display_name, deleterule)
return RedirectResponse(url="/rules", status_code=303)
async def users_edit_post(request):
"""Updates the given user with settings passed as form parameters."""
try:
users.read_users()
except:
return PlainTextResponse(
'Configuration is being updated. Try again in a minute.')
edituser = request.path_params["user"]
form = dict(await request.form())
if not edituser in users.users_list:
return PlainTextResponse('User does not exist anymore.')
users.users_list[edituser]["email"] = form["email"]
if form["password"]:
users.users_list[edituser]["password"] = users.hash_password(
form["password"])
users.users_list[edituser]["change_password"] = "******"
# Only admins are allowed to change the admin status, and the current user
# cannot change the status for himself (which includes the settings page)
if (request.user.is_admin) and (request.user.display_name != edituser):
users.users_list[edituser]["is_admin"] = form["is_admin"]
if (request.user.is_admin):
users.users_list[edituser]["permissions"] = form["permissions"]
try:
users.save_users()
except:
return PlainTextResponse(
'ERROR: Unable to write user list. Try again.')
logger.info(f'Edited user {edituser}')
monitor.send_webgui_event(monitor.w_events.USER_EDIT,
request.user.display_name, edituser)
if "own_settings" in form:
return RedirectResponse(url='/', status_code=303)
else:
return RedirectResponse(url='/users', status_code=303)
async def logout(request):
"""Logouts the users by clearing the session cookie."""
monitor.send_webgui_event(monitor.w_events.LOGOUT,
request.user.display_name, "")
request.session.clear()
return RedirectResponse(url='/login')
