FEA: Migrated to rocket v0.5-rc.1

Cargo.toml

@@ -13,7 +13,6 @@ serde = { version = "1.0.125", features = ["derive"] }
 serde_json = "1.0.64"
 log = "0.4.14"
 env_logger = "0.8.3"
-rocket = "0.4.10"
 diesel = { version = "1.4.6", features = ["postgres", "uuidv07", "chrono", "serde_json"] } #uuidv07 vs uuid to use uuid >= 0.7
 diesel_geometry = "1.4.0"
 uuid = { version = "0.8.2", features = ["serde", "v4"] }
@@ -21,10 +20,12 @@ rust-argon2 = "0.8.3"
 chrono = { version = "0.4.19", features = ["serde"] }
 rand = "0.8.3"
 iban_validate = "4.0.0"
-lettre = "0.9.5"
+base64 = "0.13.0"
-lettre_email = "0.9.4"
 
-[dependencies.rocket_contrib]
+[dependencies.rocket]
-version = "0.4.7"
+version = "0.5.0-rc.1"
-default-features = false
+features = ["json", "secrets", "uuid"]
-features = ["handlebars_templates", "serve", "json"]
+
+[dependencies.rocket_dyn_templates]
+version = "0.1.0-rc.1"
+features = ["handlebars"]

Rocket.toml

@@ -1,21 +1,21 @@
-[development]
+[debug]
-address = "localhost"
+address = "127.0.0.1"
 port = 8000
 keep_alive = 5
-log = "normal"
+log = "debug"
 limits = { forms = 32768 }
 template_dir = "resources/templates"
 
 [staging]
-address = "0.0.0.0"
+address = "127.0.0.1"
 port = 8000
 keep_alive = 5
 log = "normal"
 limits = { forms = 32768 }
 template_dir = "resources/templates"
 
-[production]
+[release]
-address = "0.0.0.0"
+address = "127.0.0.1"
 port = 8000
 keep_alive = 5
 log = "critical"

resources/templates/versiontag.hbs

@@ -1 +1 @@
-v0.2-16-g96fc203
+v0.2-19-gdbc762a

src/database/controller/api_members.rs

@@ -18,7 +18,7 @@ pub fn get_raw_member_search_result(
 ) -> Result<RawMemberSearchResult, diesel::result::Error> {
     use crate::schema::members::dsl::*;
 
-    let connection = establish_connection(&settings);
+    let connection = establish_connection(settings);
 
     let short_member: Result<RawMemberSearchResult, diesel::result::Error> = members
         .filter(entity_id.eq(member_entity_id))
@@ -63,7 +63,7 @@ pub fn get_raw_member_search_result_by_name(
 ) -> Result<Vec<RawMemberSearchResult>, diesel::result::Error> {
     use crate::schema::members::dsl::*;
 
-    let connection = establish_connection(&settings);
+    let connection = establish_connection(settings);
 
     let splitted_name: Vec<&str> = member_name.split_whitespace().collect();
 
@@ -131,7 +131,7 @@ pub fn delete_entity_deprecated(
 ) -> Result<usize, diesel::result::Error> {
     use crate::schema::entities::dsl::*;
 
-    let connection = establish_connection(&settings);
+    let connection = establish_connection(settings);
 
     match diesel::delete(entities.filter(entity_id.eq(entity_id_to_delete))).execute(&connection) {
         Ok(size) => Ok(size),

src/database/controller/members_groups.rs

@@ -46,7 +46,7 @@ pub fn get_member_search_results_in_group(
         let readable = check_access_to_member_and_group(
             settings,
             member.entity_id,
-            get_groups_for_member(&settings, member.entity_id),
+            get_groups_for_member(settings, member.entity_id),
             caller_entity_id,
             crate::permissions::modules::member_management::profile::VIEW.to_string(),
         );

src/helper/handlebars_in_list_helper.rs

@@ -1,78 +1,72 @@
-use rocket_contrib::templates::handlebars::{
+use rocket_dyn_templates::handlebars::{
     Context, Handlebars, Helper, HelperDef, HelperResult, Output, RenderContext, RenderError,
     Renderable,
 };
 
-#[derive(Clone, Copy)]
-pub(crate) struct InListHelper;
 /// Implements an "if_in_list" block helper for string vectors.
 /// Will render true block if one of the parameters 1-x is found in list.
-impl HelperDef for InListHelper {
+pub fn in_list_block_helper<'reg, 'rc>(h: &Helper<'reg, 'rc>,
-    fn call<'reg: 'rc, 'rc>(
+                                   r: &'reg Handlebars<'reg>,
-        &self,
+                                   ctx: &'rc Context,
-        h: &Helper<'reg, 'rc>,
+                                   rc: &mut RenderContext<'reg, 'rc>,
-        r: &'reg Handlebars,
+                                   out: &mut dyn Output
-        ctx: &Context,
+) -> HelperResult{
-        rc: &mut RenderContext<'reg>,
+    let list = h.param(0).unwrap();
-        out: &mut dyn Output,
+    let mut to_find: Vec<&str> = vec![];
-    ) -> HelperResult {
-        let list = h.param(0).unwrap();
-        let mut to_find: Vec<&str> = vec![];
 
-        let mut count: usize = 1;
+    let mut count: usize = 1;
-        loop {
+    loop {
-            match h.param(count) {
+        match h.param(count) {
-                None => break,
+            None => break,
-                Some(val) => {
+            Some(val) => {
-                    match val.value().as_str() {
+                match val.value().as_str() {
-                        Some(value) => to_find.push(value),
+                    Some(value) => to_find.push(value),
-                        None => {
+                    None => {
-                            return Err(RenderError::new(
+                        return Err(RenderError::new(
-                                "wrong parameter type. Should be a String.",
+                            "wrong parameter type. Should be a String.",
-                            ))
+                        ))
-                        }
+                    }
-                    };
+                };
-                }
             }
-            count = count + 1;
         }
+        count = count + 1;
+    }
 
-        let list: &Vec<serde_json::Value> = match list.value().as_array() {
+    let list: &Vec<serde_json::Value> = match list.value().as_array() {
-            Some(array) => array,
+        Some(array) => array,
+        None => {
+            return Err(RenderError::new(
+                "wrong parameter type. Should be array/Vec.",
+            ))
+        }
+    };
+
+    let mut found = false;
+
+    for value in list {
+        let string = match value.as_str() {
+            Some(string) => string,
             None => {
                 return Err(RenderError::new(
-                    "wrong parameter type. Should be array/Vec.",
+                    "wrong parameter type. Should be string array/string Vec.",
                 ))
             }
         };
 
-        let mut found = false;
+        if to_find.contains(&string) {
-
+            found = true;
-        for value in list {
+            break;
-            let string = match value.as_str() {
-                Some(string) => string,
-                None => {
-                    return Err(RenderError::new(
-                        "wrong parameter type. Should be string array/string Vec.",
-                    ))
-                }
-            };
-
-            if to_find.contains(&string) {
-                found = true;
-                break;
-            }
-        }
-
-        if found {
-            h.template()
-                .map(|t| t.render(r, ctx, rc, out))
-                .unwrap_or(Ok(()))
-        } else {
-            //render inverse template (else block), if not found in list.
-            h.inverse()
-                .map(|t| t.render(r, ctx, rc, out))
-                .unwrap_or(Ok(()))
         }
     }
+
+    if found {
+        h.template()
+            .map(|t| t.render(r, ctx, rc, out))
+            .unwrap_or(Ok(()))
+    } else {
+        //render inverse template (else block), if not found in list.
+        h.inverse()
+            .map(|t| t.render(r, ctx, rc, out))
+            .unwrap_or(Ok(()))
+    }
 }

src/helper/mail_templates.rs

@@ -1,5 +1,5 @@
-use rocket_contrib::templates::handlebars::Handlebars;
+use rocket_dyn_templates::handlebars::Handlebars;
 
-pub struct MailTemplates{
+pub struct MailTemplates<'a>{
-    pub registry: Handlebars,
+    pub registry: Handlebars<'a>,
 }

src/helper/server_errors.rs

@@ -10,20 +10,13 @@ use rocket::response::status::Custom;
 /// Catches all 401 errors and redirects to front page to show error / portal page if cookie valled
 /// Will be called when session cookies are invalid / if user has no permission to access feature
 #[catch(401)]
-pub fn unauthorized<'a>(req: &Request) -> Result<Redirect, Response<'a>> {
+pub async fn unauthorized (req: & Request<'_>) -> Redirect {
-    warn!("URI: {}", req.uri().to_string());
+    let storage = match req.guard::<&State<SessionCookieStorage>>().await {
-    if req.uri().to_string().find("/api/http_basic_auth").is_some(){
-        let mut res = Response::new();
-        res.set_status(Status::Unauthorized);
-        res.set_raw_header("WWW-Authenticate", "Basic");
-        return Err(res.respond_to(req).unwrap())
-    }
-    let storage = match req.guard::<State<SessionCookieStorage>>() {
         Outcome::Success(storage) => storage,
-        _ => return Ok(Redirect::to("/?error=unauthorized")),
+        _ => return Redirect::to("/?error=unauthorized"),
     };
     let settings = req
-        .guard::<State<Settings>>()
+        .guard::<&State<Settings>>().await
         .expect("Settings not available!");
     match req.cookies().get_private("session") {
         Some(cookie) => match storage.get(cookie.value().to_string()) {
@@ -33,11 +26,11 @@ pub fn unauthorized<'a>(req: &Request) -> Result<Redirect, Response<'a>> {
                     .checked_add_signed(Duration::seconds(settings.application.session_timeout))
                     .expect("Session timeout specified in configuration is too great!");
                 storage.update(updated_cookie);
-                Ok(Redirect::to("/portal?error=unauthorized"))
+                Redirect::to("/portal?error=unauthorized")
             }
-            Err(_) => Ok(Redirect::to("/?error=unauthorized")),
+            Err(_) => Redirect::to("/?error=unauthorized"),
         },
-        None => Ok(Redirect::to("/?error=unauthorized")),
+        None => Redirect::to("/?error=unauthorized"),
     }
 }
 

src/helper/translate_diesel_error.rs

@@ -1,5 +1,5 @@
 use crate::modules::api::model::api_outcome::{ApiError, ApiErrorWrapper};
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 
 /// Transforms diesel error into ApiErrorWrapper with proper error message.
 /// Currently checks for NotFound and UniquieViolation

src/helper/user_request_guard.rs

@@ -7,16 +7,17 @@ use rocket::http::Status;
 use rocket::request::{FromRequest, Outcome};
 use rocket::{request, Request, State};
 
-impl<'a, 'r> FromRequest<'a, 'r> for SessionCookie {
+#[rocket::async_trait]
+impl<'r> FromRequest<'r> for SessionCookie {
     type Error = SessionCookieError;
 
-    fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
+    async fn from_request(request: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
-        let storage = match request.guard::<State<SessionCookieStorage>>() {
+        let storage = match request.guard::<&State<SessionCookieStorage>>().await {
             Outcome::Success(storage) => storage,
             _ => return Outcome::Failure((Status::Unauthorized, SessionCookieError::Unavailable)),
         };
         let settings = request
-            .guard::<State<Settings>>()
+            .guard::<&State<Settings>>().await
             .expect("Settings not available!");
 
         match request.cookies().get_private("session") {

src/main.rs

@@ -1,9 +1,6 @@
-#![feature(proc_macro_hygiene, decl_macro)]
-
 extern crate config;
 #[macro_use]
 extern crate diesel;
-#[macro_use]
 extern crate log;
 #[macro_use]
 extern crate rocket;
@@ -14,26 +11,29 @@ extern crate serde_derive;
 extern crate argon2;
 extern crate chrono;
 extern crate iban;
+extern crate base64;
 
-use crate::helper::handlebars_in_list_helper::InListHelper;
+use crate::helper::handlebars_in_list_helper::in_list_block_helper;
 use crate::helper::mail_queue::queue::MailQueue;
 use crate::helper::mail_templates::MailTemplates;
 use crate::helper::session_cookies::model::SessionCookieStorage;
 use helper::settings::Settings;
-use rocket_contrib::serve::StaticFiles;
-use rocket_contrib::templates::handlebars::Handlebars;
-use rocket_contrib::templates::Template;
 use std::io::Write;
 use std::process::Command;
 use std::sync::Arc;
 use std::{thread, time};
+use rocket_dyn_templates::Template;
+use rocket::fs::FileServer;
+use rocket_dyn_templates::handlebars::Handlebars;
+
 pub mod database;
 pub mod helper;
 pub mod modules;
 pub mod permissions;
 pub mod schema;
 
-fn main() {
+#[launch]
+fn rocket() -> _ {
     env_logger::init(); //Initializes logger. Set environment variable RUST_LOG=debug|info|warn|error to set loglevel
 
     let settings = match Settings::new() {
@@ -88,9 +88,7 @@ fn main() {
     let mut mail_templates = MailTemplates {
         registry: Handlebars::new(),
     };
-    match mail_templates
+    match mail_templates.registry.register_template_file("password-reset-de", "resources/mail_templates/password-reset-de.hbs")
-        .registry
-        .register_templates_directory(".hbs", "resources/mail_templates")
     {
         Ok(_) => {}
         Err(e) => {
@@ -99,7 +97,7 @@ fn main() {
         }
     }
 
-    rocket::ignite()
+    rocket::build()
         .manage(settings)
         .manage(cookie_storage)
         .manage(mail_queue)
@@ -214,12 +212,11 @@ fn main() {
                 modules::admin_settings::permissions::settings_permissions,
             ],
         )
-        .mount("/css", StaticFiles::from("resources/css"))
+        .mount("/css", FileServer::from("resources/css"))
-        .mount("/js", StaticFiles::from("resources/js"))//TODO: Replace popper and bootstrap with local files
+        .mount("/js", FileServer::from("resources/js"))//TODO: Replace popper and bootstrap with local files
-        .mount("/img", StaticFiles::from("resources/images"))
+        .mount("/img", FileServer::from("resources/images"))
-        .mount("/templates", StaticFiles::from("resources/ajax_templates"))
+        .mount("/templates", FileServer::from("resources/ajax_templates"))
         .attach(Template::custom(|engine|{
-            engine.handlebars.register_helper("if_in_list", Box::new(InListHelper));
+            engine.handlebars.register_helper("if_in_list", Box::new(in_list_block_helper));
         }))
-        .launch();
+}
-}

src/modules/admin_settings/permissions.rs

@@ -1,10 +1,11 @@
 use crate::helper::session_cookies::model::SessionCookie;
 use rocket::State;
 use crate::helper::settings::Settings;
-use rocket_contrib::templates::Template;
+
 use rocket::http::Status;
 use crate::helper::sitebuilder::model::sidebar::Sidebar;
 use crate::helper::sitebuilder::model::general::{Header, Stylesheet, Footer, Script};
+use rocket_dyn_templates::Template;
 
 #[derive(Serialize)]
 pub struct SettingsModule {
@@ -15,7 +16,7 @@ pub struct SettingsModule {
 }
 
 #[get("/portal/settings/permissions")]
-pub fn settings_permissions(cookie: SessionCookie, settings: State<Settings>) -> Result<Template, Status> {
+pub fn settings_permissions(cookie: SessionCookie, settings: &State<Settings>) -> Result<Template, Status> {
     let member = match cookie.member {
         //Unwraps member from cookie or send user to login if no member specified (user skipped member selection)
         Some(member) => member,

src/modules/api/appointments/create.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::database::model::appointments::Appointment;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
@@ -31,7 +31,7 @@ pub struct CreateAppointmentData{
 /// * modules.scheduler.appointments.edit on specified entity
 #[post("/api/appointments", format = "json", data = "<create_appointment_data>")]
 pub fn create_appointment(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     create_appointment_data: Json<CreateAppointmentData>,
 ) -> Result<Json<Appointment>, Json<ApiErrorWrapper>> {
@@ -40,7 +40,7 @@ pub fn create_appointment(
 
     let apentity_id : uuid::Uuid = parse_uuid_string(cad.entity_id)?;
 
-    if !check_access_to_resource(&settings, caller.entity_id, apentity_id, crate::permissions::modules::scheduler::appointments::EDIT){
+    if !check_access_to_resource(settings, caller.entity_id, apentity_id, crate::permissions::modules::scheduler::appointments::EDIT){
         return Err(Json(
             ApiError::new(403, "Keine Berechtigung, Termine anzulegen!".to_string()).to_wrapper(),
         ));
@@ -55,7 +55,7 @@ pub fn create_appointment(
     };
     let aptype_id : uuid::Uuid = parse_uuid_string(cad.type_id)?;
 
-    match add_appointment(&settings, aptype_id, apentity_id, apdate){
+    match add_appointment(settings, aptype_id, apentity_id, apdate){
         Ok(appointment) => Ok(Json(appointment)),
         Err(e) => Err(translate_diesel(e))
     }

src/modules/api/appointments/delete.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 
 
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
@@ -23,25 +23,25 @@ use crate::database::controller::appointments::{remove_appointment, get_appointm
 /// * modules.scheduler.appointments.edit on specified entity
 #[delete("/api/appointments/<appointment_id>", format = "json")]
 pub fn delete_appointment(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     appointment_id: String,
 ) -> Result<(), Json<ApiErrorWrapper>> {
     let caller = parse_member_cookie(cookie.member)?;
     let ap_id : uuid::Uuid = parse_uuid_string(appointment_id)?;
 
-    let ap = match get_appointment_with_id(&settings, ap_id){
+    let ap = match get_appointment_with_id(settings, ap_id){
         Ok(ap) => ap,
         Err(e) => return Err(translate_diesel(e))
     };
 
-    if !check_access_to_resource(&settings, caller.entity_id, ap.entity_id, crate::permissions::modules::scheduler::appointments::EDIT){
+    if !check_access_to_resource(settings, caller.entity_id, ap.entity_id, crate::permissions::modules::scheduler::appointments::EDIT){
         return Err(Json(
             ApiError::new(403, "Keine Berechtigung, Termine zu löschen!".to_string()).to_wrapper(),
         ));
     }
 
-    match remove_appointment(&settings, ap_id){
+    match remove_appointment(settings, ap_id){
         Ok(_) => Ok(()),
         Err(e) => Err(translate_diesel(e))
     }

src/modules/api/appointments/read.rs

@@ -2,7 +2,7 @@ use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
 use crate::database::model::appointments::{AppointmentType, Appointment};
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 use crate::database::controller::appointments::{get_appointment_types, get_appointment_for_entity};
@@ -22,12 +22,12 @@ use crate::database::controller::members::check_access_to_resource;
 /// * None
 #[get("/api/appointments/types", format = "json")]
 pub fn read_appointment_types(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
 ) -> Result<Json<Vec<AppointmentType>>, Json<ApiErrorWrapper>> {
     parse_member_cookie(cookie.member)?;
 
-    match get_appointment_types(&settings){
+    match get_appointment_types(settings){
         Ok(at) => Ok(Json(at)),
         Err(e) => Err(translate_diesel(e)),
     }
@@ -46,20 +46,20 @@ pub fn read_appointment_types(
 /// * modules.scheduler.appointments.view
 #[get("/api/appointments?<entity_id>", format = "json")]
 pub fn read_appointments_for_entity(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     entity_id: String,
 ) -> Result<Json<Vec<Appointment>>, Json<ApiErrorWrapper>> {
     let caller = parse_member_cookie(cookie.member)?;
     let entity_id = parse_uuid_string(entity_id)?;
 
-    if !check_access_to_resource(&settings, caller.entity_id, entity_id, crate::permissions::modules::scheduler::appointments::VIEW){
+    if !check_access_to_resource(settings, caller.entity_id, entity_id, crate::permissions::modules::scheduler::appointments::VIEW){
         return Err(Json(
             ApiError::new(403, "Keine Berechtigung, Termine anzuzeigen!".to_string()).to_wrapper(),
         ));
     }
 
-    match get_appointment_for_entity(&settings, entity_id){
+    match get_appointment_for_entity(settings, entity_id){
         Ok(at) => Ok(Json(at)),
         Err(e) => Err(translate_diesel(e)),
     }

src/modules/api/communicator/create.rs

@@ -2,7 +2,7 @@ use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::member_management::controller::parser::parse_member_cookie;
 use crate::helper::mail_queue::queue::{Mail, MailQueue};
 
@@ -33,7 +33,7 @@ pub struct ApiEmail{
 }
 
 #[post("/api/communicator/email", format = "json", data = "<mail>")]
-pub fn create_email(mq: State<Arc<MailQueue>>, settings: State<Settings>, cookie: SessionCookie, mail: Json<ApiEmail>) -> Result<(), Json<ApiErrorWrapper>>{
+pub fn create_email(mq: &State<Arc<MailQueue>>, settings: &State<Settings>, cookie: SessionCookie, mail: Json<ApiEmail>) -> Result<(), Json<ApiErrorWrapper>>{
     let caller = parse_member_cookie(cookie.member)?;
     if !caller.has_permission(crate::permissions::modules::communicator::email::SEND.to_string()){
         return Err(Json(ApiError::new(403, "Keine Berechtigung Email zu versenden!".to_string()).to_wrapper()));
@@ -54,7 +54,7 @@ pub fn create_email(mq: State<Arc<MailQueue>>, settings: State<Settings>, cookie
     match mail.to_members{
         Some(members) => {
             for member_id in members{
-                match get_member_email_addresses(&settings, member_id){
+                match get_member_email_addresses(settings, member_id){
                     Ok(mut addresses) => {
                         to.append(addresses.as_mut());
                     }
@@ -76,7 +76,7 @@ pub fn create_email(mq: State<Arc<MailQueue>>, settings: State<Settings>, cookie
     match mail.cc_members{
         Some(members) => {
             for member_id in members{
-                match get_member_email_addresses(&settings, member_id){
+                match get_member_email_addresses(settings, member_id){
                     Ok(mut addresses) => {
                         cc.append(addresses.as_mut());
                     }
@@ -98,7 +98,7 @@ pub fn create_email(mq: State<Arc<MailQueue>>, settings: State<Settings>, cookie
     match mail.bcc_members{
         Some(members) => {
             for member_id in members{
-                match get_member_email_addresses(&settings, member_id){
+                match get_member_email_addresses(settings, member_id){
                     Ok(mut addresses) => {
                         bcc.append(addresses.as_mut());
                     }
@@ -116,8 +116,8 @@ pub fn create_email(mq: State<Arc<MailQueue>>, settings: State<Settings>, cookie
         None => {}
         Some(groups) => {
             for group in groups{
-                if !check_access_to_resource(&settings, caller.entity_id, group, crate::permissions::modules::communicator::email::SEND){
+                if !check_access_to_resource(settings, caller.entity_id, group, crate::permissions::modules::communicator::email::SEND){
-                    match get_group(&settings, group){
+                    match get_group(settings, group){
                         Ok(group) => {
                             return Err(Json(ApiError::new(403, format!("Keine Berechtigung eine Email an die Gruppe {} zu schicken!", group.name)).to_wrapper()))
                         }
@@ -126,7 +126,7 @@ pub fn create_email(mq: State<Arc<MailQueue>>, settings: State<Settings>, cookie
                         }
                     }
                 }
-                match get_group_email_addresses(&settings, group){
+                match get_group_email_addresses(settings, group){
                     Ok(mut emails) => {
                         bcc.append(emails.as_mut());
                     }
@@ -142,8 +142,8 @@ pub fn create_email(mq: State<Arc<MailQueue>>, settings: State<Settings>, cookie
         None => {}
         Some(units) => {
             for unit in units{
-                if !check_access_to_resource(&settings, caller.entity_id, unit, crate::permissions::modules::communicator::email::SEND){
+                if !check_access_to_resource(settings, caller.entity_id, unit, crate::permissions::modules::communicator::email::SEND){
-                    match get_unit(&settings, unit){
+                    match get_unit(settings, unit){
                         Ok(unit) => {
                             return Err(Json(ApiError::new(403, format!("Keine Berechtigung eine Email an die Einheit {} zu schicken!", unit.name)).to_wrapper()))
                         }
@@ -152,7 +152,7 @@ pub fn create_email(mq: State<Arc<MailQueue>>, settings: State<Settings>, cookie
                         }
                     }
                 }
-                match get_unit_email_addresses(&settings, unit){
+                match get_unit_email_addresses(settings, unit){
                     Ok(mut emails) => {
                         bcc.append(emails.as_mut());
                     }

src/modules/api/event_organisers/create.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::database::model::organisers::Organiser;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::parse_member_cookie;
@@ -21,7 +21,7 @@ pub struct CreateOrganiserData{
 
 #[post("/api/event_organisers", format = "json", data = "<create_organiser_data>")]
 pub fn create_organiser(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     create_organiser_data: Json<CreateOrganiserData>,
 ) -> Result<Json<Organiser>, Json<ApiErrorWrapper>> {
@@ -34,7 +34,7 @@ pub fn create_organiser(
 
     let organiser_create_data = create_organiser_data.into_inner();
 
-    let entity_id2 = match generate_entity(&settings){
+    let entity_id2 = match generate_entity(settings){
         Ok(ent) => ent,
         Err(_e) => return Err(Json(ApiError::new(500, "Konnte keine neue Entität anlegen!".to_string()).to_wrapper()))
     };
@@ -49,7 +49,7 @@ pub fn create_organiser(
         other: organiser_create_data.other
     };
 
-    match add_organiser(&settings, input){
+    match add_organiser(settings, input){
         Ok(org) => Ok(Json(org)),
         Err(e) => Err(translate_diesel(e))
     }

src/modules/api/event_organisers/delete.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::parse_member_cookie;
 
@@ -11,7 +11,7 @@ use crate::database::controller::entities::remove_entity;
 
 #[delete("/api/event_organisers", format = "json", data = "<organiser_list>")]
 pub fn delete_organisers(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     organiser_list: Json<Vec<uuid::Uuid>>,
 ) -> Result<(), Json<ApiErrorWrapper>> {
@@ -25,7 +25,7 @@ pub fn delete_organisers(
     let organiser_list = organiser_list.into_inner();
 
     for organiser in organiser_list {
-        match remove_entity(&settings, organiser){
+        match remove_entity(settings, organiser){
                 Ok(_) => {}
                 Err(e) => return Err(translate_diesel(e)),
         }

src/modules/api/event_organisers/read.rs

@@ -2,7 +2,7 @@ use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 use crate::database::model::organisers::Organiser;
 
@@ -20,14 +20,14 @@ pub struct OrganiserList{
 /// * modules.event_management.organisers.view (optional, limited set will provided if permission missing)
 #[get("/api/event_organisers/<entity_id>", format = "json")]
 pub fn read_organiser(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     entity_id: String,
 ) -> Result<Json<Organiser>, Json<ApiErrorWrapper>>{
     let caller = parse_member_cookie(cookie.member)?;
     let entity_id = parse_uuid_string(entity_id)?;
 
-    match get_organiser(&settings, entity_id){
+    match get_organiser(settings, entity_id){
         Ok(organiser) => {
             if caller.has_permission(crate::permissions::modules::event_management::organisers::VIEW.to_string()){
                 Ok(Json(organiser))
@@ -46,7 +46,7 @@ pub fn read_organiser(
 
 #[get("/api/event_organisers?<entries>&<page>&<q>", format = "json")]
 pub fn read_organisers(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     entries: Option<i64>, //TODO: replace with limit/offset
     page: Option<i64>,
@@ -87,12 +87,12 @@ pub fn read_organisers(
         total_organiser_count: 0
     };
 
-    match get_organisers(&settings, entries, (page-1)*entries, q){
+    match get_organisers(settings, entries, (page-1)*entries, q){
         Ok(organisers) => res.organisers = organisers,
         Err(e) => return Err(translate_diesel(e))
     };
 
-    match get_organiser_count(&settings){
+    match get_organiser_count(settings){
         Ok(count) => res.total_organiser_count = count,
         Err(e) => return Err(translate_diesel(e))
     };

src/modules/api/event_organisers/update.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::event_organisers::create::CreateOrganiserData;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
@@ -11,7 +11,7 @@ use crate::helper::translate_diesel_error::translate_diesel;
 
 #[put("/api/event_organisers/<organiser_id>", format = "json", data = "<change_organiser_data>")]
 pub fn update_organiser(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     change_organiser_data: Json<CreateOrganiserData>,
     organiser_id: String,
@@ -37,7 +37,7 @@ pub fn update_organiser(
         other: cod.other
     };
 
-    match change_organiser(&settings, org){
+    match change_organiser(settings, org){
         Ok(_) => Ok(()),
         Err(e) => Err(translate_diesel(e))
     }

src/modules/api/events/create.rs

@@ -2,7 +2,7 @@ use chrono::NaiveDateTime;
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_option_uuid};
 use crate::database::model::events::Event;
@@ -28,7 +28,7 @@ pub struct CreateEventData{
 
 #[post("/api/events", format = "json", data = "<create_event_data>")]
 pub fn create_event(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     create_event_data: Json<CreateEventData>,
 ) -> Result<Json<Event>, Json<ApiErrorWrapper>> {
@@ -41,7 +41,7 @@ pub fn create_event(
 
     let ecd = create_event_data.into_inner();
 
-    let entity_id2 = match generate_entity(&settings){
+    let entity_id2 = match generate_entity(settings){
         Ok(ent) => ent,
         Err(_e) => return Err(Json(ApiError::new(500, "Konnte keine neue Entität anlegen!".to_string()).to_wrapper()))
     };
@@ -82,7 +82,7 @@ pub fn create_event(
         other_intern: ecd.other_intern
     };
 
-    match add_event(&settings, input){
+    match add_event(settings, input){
         Ok(event) => Ok(Json(event)),
         Err(e) => Err(translate_diesel(e))
     }

src/modules/api/events/delete.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 use crate::database::controller::entities::remove_entity;
@@ -9,7 +9,7 @@ use crate::helper::translate_diesel_error::translate_diesel;
 
 #[delete("/api/events/<event_id>", format = "json")]
 pub fn delete_event(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     event_id: String,
 ) -> Result<(), Json<ApiErrorWrapper>> {
@@ -22,7 +22,7 @@ pub fn delete_event(
         ));
     }
 
-    match remove_entity(&settings, event_id){
+    match remove_entity(settings, event_id){
         Ok(_) => {}
         Err(e) => return Err(translate_diesel(e)),
     }

src/modules/api/events/event_units/position/create.rs

@@ -1,7 +1,7 @@
 use crate::helper::session_cookies::model::SessionCookie;
 use rocket::State;
 use crate::helper::settings::Settings;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 use crate::database::controller::entities::generate_entity;
@@ -19,7 +19,7 @@ pub struct CreatePositionData{
 
 #[post("/api/events/units/positions", format = "json", data = "<create_position_data>")]
 pub fn create_event_unit_position(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     create_position_data: Json<CreatePositionData>,
 ) -> Result<Json<EventUnitPosition>, Json<ApiErrorWrapper>> {
@@ -31,7 +31,7 @@ pub fn create_event_unit_position(
     }
 
     let create_position_data = create_position_data.into_inner();
-    let entity_id = match generate_entity(&settings){
+    let entity_id = match generate_entity(settings){
         Ok(entity) => entity,
         Err(_e) => return Err(Json(ApiError::new(500, "Konnte keine neue Entität anlegen.".to_string()).to_wrapper())),
     };
@@ -50,7 +50,7 @@ pub fn create_event_unit_position(
         requirements
     };
 
-    match add_event_unit_position(&settings, event_position){
+    match add_event_unit_position(settings, event_position){
         Ok(eup) => Ok(Json(eup)),
         Err(e) =>  Err(translate_diesel(e))
     }
@@ -68,7 +68,7 @@ pub struct CreateVehiclePositionData{
 
 #[post("/api/events/units/vehicle_positions", format = "json", data = "<create_vehicle_position_data>")]
 pub fn create_event_unit_vehicle_position(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     create_vehicle_position_data: Json<CreateVehiclePositionData>,
 ) -> Result<Json<EventUnitVehiclePosition>, Json<ApiErrorWrapper>> {
@@ -80,7 +80,7 @@ pub fn create_event_unit_vehicle_position(
     }
 
     let cvpd = create_vehicle_position_data.into_inner();
-    let entity_id = match generate_entity(&settings){
+    let entity_id = match generate_entity(settings){
         Ok(entity) => entity,
         Err(_e) => return Err(Json(ApiError::new(500, "Konnte keine neue Entität anlegen.".to_string()).to_wrapper())),
     };
@@ -93,7 +93,7 @@ pub fn create_event_unit_vehicle_position(
         template_id: parse_uuid_string(cvpd.template_id)?,
     };
 
-    match add_vehicle_position(&settings, pos){
+    match add_vehicle_position(settings, pos){
         Ok(pos) => Ok(Json(pos)),
         Err(e) => Err(translate_diesel(e))
     }

src/modules/api/events/event_units/position/delete.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::parse_member_cookie;
 use crate::database::controller::entities::remove_entity;
@@ -9,7 +9,7 @@ use crate::helper::translate_diesel_error::translate_diesel;
 
 #[delete("/api/events/units/positions", format = "json", data = "<delete_list>")]
 pub fn delete_event_unit_positions(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     delete_list: Json<Vec<uuid::Uuid>>,
 ) -> Result<(), Json<ApiErrorWrapper>> {
@@ -23,7 +23,7 @@ pub fn delete_event_unit_positions(
     let delete_list = delete_list.into_inner();
 
     for position in delete_list {
-        match remove_entity(&settings, position){
+        match remove_entity(settings, position){
             Ok(_) => {}
             Err(e) => return Err(translate_diesel(e)),
         }
@@ -34,7 +34,7 @@ pub fn delete_event_unit_positions(
 
 #[delete("/api/events/units/vehicle_positions", format = "json", data = "<delete_list>")]
 pub fn delete_event_unit_vehicle_positions(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     delete_list: Json<Vec<uuid::Uuid>>,
 ) -> Result<(), Json<ApiErrorWrapper>> {
@@ -48,7 +48,7 @@ pub fn delete_event_unit_vehicle_positions(
     let delete_list = delete_list.into_inner();
 
     for position in delete_list {
-        match remove_entity(&settings, position){
+        match remove_entity(settings, position){
             Ok(_) => {}
             Err(e) => return Err(translate_diesel(e)),
         }

src/modules/api/events/event_units/position/read.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::database::model::events::EventUnitPosition;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
@@ -17,7 +17,7 @@ pub struct EventUnitPositionList{
 
 #[get("/api/events/units/positions?<limit>&<offset>&<q>", format = "json")]
 pub fn read_event_unit_position(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     limit: Option<i64>,
     offset: Option<i64>,
@@ -39,12 +39,12 @@ pub fn read_event_unit_position(
         None => 0,
     };
 
-    let positions = match get_event_unit_positions(&settings, limit, offset, q){
+    let positions = match get_event_unit_positions(settings, limit, offset, q){
         Ok(pos) => pos,
         Err(e) => return Err(translate_diesel(e))
     };
 
-    let total_position_count = match get_event_unit_positions_count(&settings){
+    let total_position_count = match get_event_unit_positions_count(settings){
         Ok(count) => count,
         Err(e) => return Err(translate_diesel(e))
     };
@@ -64,13 +64,13 @@ pub struct PositionCheckResult{
 
 #[get("/api/events/units/positions/<position_id>/check_requirements?<target_to_check>", format = "json")]
 pub fn get_check_position_requirements(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     position_id: String,
     target_to_check: String,
 ) -> Result<Json<PositionCheckResult>, Json<ApiErrorWrapper>> {
     let caller = parse_member_cookie(cookie.member)?;
-    match check_position_requirements(&settings, parse_uuid_string(position_id)?, parse_uuid_string(target_to_check)?){
+    match check_position_requirements(settings, parse_uuid_string(position_id)?, parse_uuid_string(target_to_check)?){
         Ok(res) => Ok(Json(PositionCheckResult{
             requirements_fulfilled: res
         })),

src/modules/api/events/event_units/position/update.rs

@@ -1,7 +1,7 @@
 use crate::helper::session_cookies::model::SessionCookie;
 use rocket::State;
 use crate::helper::settings::Settings;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 
@@ -12,7 +12,7 @@ use crate::modules::api::events::event_units::position::create::CreatePositionDa
 
 #[put("/api/events/units/positions/<entity_id>", format = "json", data = "<update_position_data>")]
 pub fn update_event_unit_position(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     update_position_data: Json<CreatePositionData>,
     entity_id : String,
@@ -41,7 +41,7 @@ pub fn update_event_unit_position(
         requirements
     };
 
-    match set_event_unit_position(&settings, event_position){
+    match set_event_unit_position(settings, event_position){
         Ok(eup) => Ok(Json(eup)),
         Err(e) =>  Err(translate_diesel(e))
     }

src/modules/api/events/event_units/templates/create.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::parse_member_cookie;
 use crate::database::controller::entities::generate_entity;
@@ -18,7 +18,7 @@ pub struct CreateTemplateData{
 
 #[post("/api/events/units/templates", format = "json", data = "<create_template_data>")]
 pub fn create_event_unit_template(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     create_template_data: Json<CreateTemplateData>,
 ) -> Result<Json<EventUnitTemplate>, Json<ApiErrorWrapper>> {
@@ -30,7 +30,7 @@ pub fn create_event_unit_template(
     }
 
     let create_template_data = create_template_data.into_inner();
-    let entity_id = match generate_entity(&settings){
+    let entity_id = match generate_entity(settings){
         Ok(entity) => entity,
         Err(_e) => return Err(Json(ApiError::new(500, "Konnte keine neue Entität anlegen.".to_string()).to_wrapper())),
     };
@@ -41,7 +41,7 @@ pub fn create_event_unit_template(
         description: create_template_data.description,
     };
 
-    match add_event_unit_template(&settings, event_position){
+    match add_event_unit_template(settings, event_position){
         Ok(eup) => Ok(Json(eup)),
         Err(e) =>  Err(translate_diesel(e))
     }

src/modules/api/events/event_units/templates/delete.rs

@@ -1,7 +1,7 @@
 use crate::helper::settings::Settings;
 use rocket::State;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 use crate::database::controller::entities::remove_entity;
@@ -10,7 +10,7 @@ use crate::database::controller::events::remove_positions_from_template;
 
 #[delete("/api/events/units/templates", format = "json", data = "<template_list>")]
 pub fn delete_templates(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     template_list: Json<Vec<uuid::Uuid>>,
 ) -> Result<(), Json<ApiErrorWrapper>> {
@@ -24,7 +24,7 @@ pub fn delete_templates(
     let template_list = template_list.into_inner();
 
     for template in template_list {
-        match remove_entity(&settings, template){
+        match remove_entity(settings, template){
             Ok(_) => {}
             Err(e) => return Err(translate_diesel(e)),
         }
@@ -35,7 +35,7 @@ pub fn delete_templates(
 
 #[delete("/api/events/units/templates/<template_id>/positions", format = "json", data = "<position_list>")]
 pub fn delete_positions_from_template(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     template_id: String,
     position_list: Json<Vec<uuid::Uuid>>,
@@ -49,7 +49,7 @@ pub fn delete_positions_from_template(
 
     let position_list = position_list.into_inner();
 
-    match remove_positions_from_template(&settings, parse_uuid_string(template_id)?, position_list){
+    match remove_positions_from_template(settings, parse_uuid_string(template_id)?, position_list){
         Ok(_) => {}
         Err(e) => return Err(translate_diesel(e)),
     }

src/modules/api/events/event_units/templates/read.rs

@@ -2,7 +2,7 @@ use crate::database::model::events::{EventUnitTemplate, EventUnitPosition, Event
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 use crate::helper::translate_diesel_error::translate_diesel;
@@ -16,7 +16,7 @@ pub struct EventUnitTemplateList{
 
 #[get("/api/events/units/templates?<limit>&<offset>&<q>", format = "json")]
 pub fn read_event_unit_templates(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     limit: Option<i64>,
     offset: Option<i64>,
@@ -38,12 +38,12 @@ pub fn read_event_unit_templates(
         None => 0,
     };
 
-    let templates = match get_event_unit_templates(&settings, limit, offset, q){
+    let templates = match get_event_unit_templates(settings, limit, offset, q){
         Ok(pos) => pos,
         Err(e) => return Err(translate_diesel(e))
     };
 
-    let total_template_count = match get_event_unit_templates_count(&settings){
+    let total_template_count = match get_event_unit_templates_count(settings){
         Ok(count) => count,
         Err(e) => return Err(translate_diesel(e))
     };
@@ -57,7 +57,7 @@ pub fn read_event_unit_templates(
 
 #[get("/api/events/units/templates/<template_id>/positions", format = "json")]
 pub fn read_event_unit_template_positions(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     template_id: String
 ) -> Result<Json<Vec<EventUnitPosition>>, Json<ApiErrorWrapper>> {
@@ -68,7 +68,7 @@ pub fn read_event_unit_template_positions(
         ));
     }
 
-    let positions = match get_event_unit_positions_for_template(&settings, parse_uuid_string(template_id)?){
+    let positions = match get_event_unit_positions_for_template(settings, parse_uuid_string(template_id)?){
         Ok(pos) => pos,
         Err(e) => return Err(translate_diesel(e))
     };
@@ -79,7 +79,7 @@ pub fn read_event_unit_template_positions(
 
 #[get("/api/events/units/templates/<template_id>/vehicle_positions", format = "json")]
 pub fn read_event_unit_template_vehicle_positions(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     template_id: String
 ) -> Result<Json<Vec<EventUnitVehiclePosition>>, Json<ApiErrorWrapper>> {
@@ -90,7 +90,7 @@ pub fn read_event_unit_template_vehicle_positions(
         ));
     }
 
-    let positions = match get_vehicle_positions_for_template(&settings, parse_uuid_string(template_id)?){
+    let positions = match get_vehicle_positions_for_template(settings, parse_uuid_string(template_id)?){
         Ok(pos) => pos,
         Err(e) => return Err(translate_diesel(e))
     };

src/modules/api/events/event_units/templates/update.rs

@@ -1,7 +1,7 @@
 use crate::helper::settings::Settings;
 use rocket::State;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 use crate::database::controller::events::{add_position_to_template, update_eu_template};
@@ -11,7 +11,7 @@ use crate::modules::api::events::event_units::templates::create::CreateTemplateD
 
 #[put("/api/events/units/templates/<template_id>/positions/<position_id>", format = "json")]
 pub fn put_position_in_template(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     template_id: String,
     position_id: String,
@@ -26,7 +26,7 @@ pub fn put_position_in_template(
     let template_id = parse_uuid_string(template_id)?;
     let position_id = parse_uuid_string(position_id)?;
 
-    match add_position_to_template(&settings, template_id, position_id){
+    match add_position_to_template(settings, template_id, position_id){
         Ok(_) => Ok(()),
         Err(e) =>  Err(translate_diesel(e))
     }
@@ -35,7 +35,7 @@ pub fn put_position_in_template(
 
 #[put("/api/events/units/templates/<template_id>", format = "json", data = "<template>")]
 pub fn update_template(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     template_id: String,
     template: Json<CreateTemplateData>,
@@ -55,7 +55,7 @@ pub fn update_template(
         description: template.description
     };
 
-    match update_eu_template(&settings, template){
+    match update_eu_template(settings, template){
         Ok(template) => Ok(Json(template)),
         Err(e) =>  Err(translate_diesel(e))
     }

src/modules/api/events/instances/create.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::database::model::events::EventUnitInstance;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
@@ -19,7 +19,7 @@ pub struct CreateInstanceData{
 
 #[post("/api/events/<event_id>/instances", format = "json", data = "<create_instance_data>")]
 pub fn create_instance(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     create_instance_data: Json<CreateInstanceData>,
     event_id: String,
@@ -37,7 +37,7 @@ pub fn create_instance(
             ApiError::new(400, "Two different event_ids in body and parameter!".to_string()).to_wrapper(),
         ))
     }
-    let entity_id = match generate_entity(&settings){
+    let entity_id = match generate_entity(settings){
         Ok(entity) => entity,
         Err(_e) => return Err(Json(ApiError::new(500, "Konnte keine neue Entität anlegen.".to_string()).to_wrapper())),
     };
@@ -49,12 +49,12 @@ pub fn create_instance(
         event_id: parse_uuid_string(event_id)?
     };
 
-    match add_position_instances_for_instance(&settings, instance.instance_id, instance.template_id){
+    match add_position_instances_for_instance(settings, instance.instance_id, instance.template_id){
         Ok(_) => {}
         Err(e) => return Err(translate_diesel(e))
     }
 
-    match add_instance(&settings, instance){
+    match add_instance(settings, instance){
         Ok(instance) => return Ok(Json(instance)),
         Err(e) => return Err(translate_diesel(e))
     }

src/modules/api/events/instances/delete.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 use crate::database::controller::entities::remove_entity;
@@ -9,7 +9,7 @@ use crate::helper::translate_diesel_error::translate_diesel;
 
 #[delete("/api/events/instances/<instance_id>", format = "json")]
 pub fn delete_instance(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     instance_id: String,
 ) -> Result<(), Json<ApiErrorWrapper>> {
@@ -20,7 +20,7 @@ pub fn delete_instance(
         ));
     }
 
-    match remove_entity(&settings, parse_uuid_string(instance_id)?){
+    match remove_entity(settings, parse_uuid_string(instance_id)?){
         Ok(_) => Ok(()),
         Err(e) => return Err(translate_diesel(e))
     }

src/modules/api/events/instances/read.rs

@@ -2,7 +2,7 @@ use crate::helper::settings::Settings;
 use rocket::State;
 use crate::helper::session_cookies::model::SessionCookie;
 use crate::database::model::events::{EventUnitInstance, EventUnitInstancePosition, EventUnitInstanceVehiclePosition};
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 use crate::database::controller::events::{get_instances, get_instance_positions, get_instance_vehicle_positions};
@@ -10,7 +10,7 @@ use crate::helper::translate_diesel_error::translate_diesel;
 
 #[get("/api/events/<event_id>/instances", format = "json", rank = 1)]
 pub fn read_instances(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     event_id: String,
 ) -> Result<Json<Vec<EventUnitInstance>>, Json<ApiErrorWrapper>> {
@@ -21,7 +21,7 @@ pub fn read_instances(
         ));
     }
 
-    match get_instances(&settings, parse_uuid_string(event_id)?){
+    match get_instances(settings, parse_uuid_string(event_id)?){
         Ok(pos) => Ok(Json(pos)),
         Err(e) => return Err(translate_diesel(e))
     }
@@ -29,7 +29,7 @@ pub fn read_instances(
 
 #[get("/api/events/instances/<instance_id>/positions", format = "json", rank = 1)]
 pub fn read_positions_for_instance(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     instance_id: String,
 ) -> Result<Json<Vec<EventUnitInstancePosition>>, Json<ApiErrorWrapper>> {
@@ -40,7 +40,7 @@ pub fn read_positions_for_instance(
         ));
     }
 
-    match get_instance_positions(&settings, parse_uuid_string(instance_id)?){
+    match get_instance_positions(settings, parse_uuid_string(instance_id)?){
         Ok(pos) => Ok(Json(pos)),
         Err(e) => return Err(translate_diesel(e))
     }
@@ -48,7 +48,7 @@ pub fn read_positions_for_instance(
 
 #[get("/api/events/instances/<instance_id>/vehicle_positions", format = "json", rank = 1)]
 pub fn read_vehicle_positions_for_instance(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     instance_id: String,
 ) -> Result<Json<Vec<EventUnitInstanceVehiclePosition>>, Json<ApiErrorWrapper>> {
@@ -59,7 +59,7 @@ pub fn read_vehicle_positions_for_instance(
         ));
     }
 
-    match get_instance_vehicle_positions(&settings, parse_uuid_string(instance_id)?){
+    match get_instance_vehicle_positions(settings, parse_uuid_string(instance_id)?){
         Ok(pos) => Ok(Json(pos)),
         Err(e) => return Err(translate_diesel(e))
     }

src/modules/api/events/instances/update.rs

@@ -1,7 +1,7 @@
 use crate::helper::settings::Settings;
 use rocket::State;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 use crate::database::controller::events::change_position_instances;
@@ -10,7 +10,7 @@ use crate::modules::event_management::check_position_requirements::{check_positi
 
 #[put("/api/events/instances/<instance_id>/positions/<position_id>/entities/<entity_id>", format = "json", rank = 1)]
 pub fn put_entity_in_position(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     instance_id: String,
     position_id: String,
@@ -22,7 +22,7 @@ pub fn put_entity_in_position(
     let entity_id = parse_uuid_string(entity_id)?;
 
     if caller.entity_id == entity_id {
-        match check_position_requirements(&settings, position_id, entity_id){
+        match check_position_requirements(settings, position_id, entity_id){
             Ok(res) => {
                 if !res{ //if member tries to add himself to a position, but don't fulfill the position requirements AND don't have the event edit permission (overwrite), abort
                     if !caller.has_permission(crate::permissions::modules::event_management::events::EDIT.to_string()) {
@@ -52,7 +52,7 @@ pub fn put_entity_in_position(
         }
     }
 
-    match change_position_instances(&settings, parse_uuid_string(instance_id)?, position_id, Some(entity_id)){
+    match change_position_instances(settings, parse_uuid_string(instance_id)?, position_id, Some(entity_id)){
         Ok(pos) => Ok(Json(pos)),
         Err(e) => return Err(translate_diesel(e))
     }
@@ -60,7 +60,7 @@ pub fn put_entity_in_position(
 
 #[delete("/api/events/instances/<instance_id>/positions/<position_id>/entities", format = "json", rank = 1)]
 pub fn remove_entity_from_position(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     instance_id: String,
     position_id: String,
@@ -72,7 +72,7 @@ pub fn remove_entity_from_position(
         ));
     }
 
-    match change_position_instances(&settings, parse_uuid_string(instance_id)?, parse_uuid_string(position_id)?, None){
+    match change_position_instances(settings, parse_uuid_string(instance_id)?, parse_uuid_string(position_id)?, None){
         Ok(pos) => Ok(Json(pos)),
         Err(e) => return Err(translate_diesel(e))
     }

src/modules/api/events/read.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::database::model::events::Event;
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string, parse_uuid};
@@ -19,7 +19,7 @@ pub struct EventList{
 
 #[get("/api/events?<start>&<end>&<limit>&<offset>&<groups>", format = "json")]
 pub fn read_events(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     start: Option<String>,
     end: Option<String>,
@@ -79,11 +79,11 @@ pub fn read_events(
         None => None,
     };
 
-    let events = match get_events(&settings, start, end, limit, offset, groups){
+    let events = match get_events(settings, start, end, limit, offset, groups){
         Ok(events) => events,
         Err(e) => return Err(translate_diesel(e)),
     };
-    let total_event_count = match get_event_count(&settings, start, end){
+    let total_event_count = match get_event_count(settings, start, end){
         Ok(count) => count,
         Err(e) => return Err(translate_diesel(e)),
     };
@@ -95,14 +95,14 @@ pub fn read_events(
 }
 
 #[get("/api/events/<entity_id>", format = "json")]
-pub fn read_event(settings: State<Settings>, cookie: SessionCookie, entity_id: String) -> Result<Json<Event>, Json<ApiErrorWrapper>>{
+pub fn read_event(settings: &State<Settings>, cookie: SessionCookie, entity_id: String) -> Result<Json<Event>, Json<ApiErrorWrapper>>{
     let caller = parse_member_cookie(cookie.member)?;
 
     if !caller.has_permission(crate::permissions::modules::event_management::events::VIEW.to_string()) {
         return Err(Json(ApiError::new(403, "Keine Berechtigung Einsatz abzurufen!".to_string()).to_wrapper()))
     }
 
-    match get_event(&settings, parse_uuid_string(entity_id)?){
+    match get_event(settings, parse_uuid_string(entity_id)?){
         Ok(event) => Ok(Json(event)),
         Err(e) => Err(translate_diesel(e)),
     }
@@ -111,14 +111,14 @@ pub fn read_event(settings: State<Settings>, cookie: SessionCookie, entity_id: S
 /// Returns events member participates in
 /// future events only
 #[get("/api/events/members/<member_id>", format = "json")]
-pub fn read_future_event_for_member(settings: State<Settings>, cookie: SessionCookie, member_id: String) -> Result<Json<Vec<Event>>, Json<ApiErrorWrapper>>{
+pub fn read_future_event_for_member(settings: &State<Settings>, cookie: SessionCookie, member_id: String) -> Result<Json<Vec<Event>>, Json<ApiErrorWrapper>>{
     let caller = parse_member_cookie(cookie.member)?;
 
     if !caller.has_permission(crate::permissions::modules::event_management::VIEW.to_string()) {
         return Err(Json(ApiError::new(403, "Keine Berechtigung Einsätze abzurufen!".to_string()).to_wrapper()))
     }
 
-    match get_events_for_member_in_future(&settings, parse_uuid_string(member_id)?){
+    match get_events_for_member_in_future(settings, parse_uuid_string(member_id)?){
         Ok(events) => Ok(Json(events)),
         Err(e) => Err(translate_diesel(e)),
     }

src/modules/api/events/types/read.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::ApiErrorWrapper;
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 use crate::database::model::events::EventType;
@@ -10,12 +10,12 @@ use crate::helper::translate_diesel_error::translate_diesel;
 
 #[get("/api/events/types", format = "json")]
 pub fn read_event_types(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
 ) -> Result<Json<Vec<EventType>>, Json<ApiErrorWrapper>> {
     let _caller = parse_member_cookie(cookie.member)?;
 
-    match get_event_types(&settings){
+    match get_event_types(settings){
         Ok(types) => Ok(Json(types)),
         Err(e) => Err(translate_diesel(e))
     }
@@ -23,14 +23,14 @@ pub fn read_event_types(
 
 #[get("/api/events/types/<type_id>", format = "json")]
 pub fn read_event_type(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     type_id: String,
 ) -> Result<Json<EventType>, Json<ApiErrorWrapper>> {
     let _caller = parse_member_cookie(cookie.member)?;
 
     let etype = parse_uuid_string(type_id)?;
-    match get_event_type(&settings, etype){
+    match get_event_type(settings, etype){
         Ok(etype) => Ok(Json(etype)),
         Err(e) => Err(translate_diesel(e))
     }

src/modules/api/events/update.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::events::create::CreateEventData;
 use crate::database::model::events::Event;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
@@ -12,7 +12,7 @@ use crate::database::controller::events::change_event;
 
 #[put("/api/events/<entity_id>", format = "json", data = "<update_event_data>")]
 pub fn update_event(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     entity_id: String,
     update_event_data: Json<CreateEventData>,
@@ -58,7 +58,7 @@ pub fn update_event(
         other_intern: ecd.other_intern
     };
 
-    match change_event(&settings, input){
+    match change_event(settings, input){
         Ok(event) => Ok(Json(event)),
         Err(e) => Err(translate_diesel(e))
     }

src/modules/api/groups/create.rs

@@ -11,7 +11,7 @@ use crate::modules::member_management::model::groups::GroupData;
 
 
 use rocket::State;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 
 #[derive(Queryable, Clone, Deserialize, Serialize)]
 pub struct GroupRolePermission {
@@ -32,7 +32,7 @@ pub struct CreateGroupData {
 
 #[post("/api/groups", format = "json", data = "<create_group_data>")]
 pub fn create_group(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     create_group_data: Json<CreateGroupData>,
 ) -> Result<Json<RawGroup>, Json<ApiErrorWrapper>> {
@@ -51,10 +51,10 @@ pub fn create_group(
         ));
     }
 
-    let group = match insert_group(&settings, create_group_data.group_data) {
+    let group = match insert_group(settings, create_group_data.group_data) {
         Ok(group) => {
             match add_group_role_permissions(
-                &settings,
+                settings,
                 group.group_id,
                 create_group_data.role_permissions,
             ) {

src/modules/api/groups/delete.rs

@@ -9,12 +9,12 @@ use crate::helper::translate_diesel_error::translate_diesel;
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 use crate::modules::api::model::api_outcome::{ApiError, ApiErrorWrapper};
 use rocket::State;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::database::controller::members_groups::remove_member_from_group;
 
 #[delete("/api/groups", format = "json", data = "<group_list>")]
 pub fn delete_groups(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     group_list: Json<Vec<uuid::Uuid>>,
 ) -> Result<(), Json<ApiErrorWrapper>> {
@@ -32,7 +32,7 @@ pub fn delete_groups(
             group,
             crate::permissions::modules::member_management::groups::DELETE,
         ) {
-            match delete_group(&settings, group) {
+            match delete_group(settings, group) {
                 Ok(_) => {}
                 Err(e) => return Err(translate_diesel(e)),
             }
@@ -49,16 +49,16 @@ pub fn delete_groups(
 }
 
 #[delete("/api/groups/<group_id>/members/<member_id>", format = "json")]
-pub fn delete_member_from_group(settings: State<Settings>, cookie: SessionCookie, group_id: String, member_id: String) -> Result<(), Json<ApiErrorWrapper>>{
+pub fn delete_member_from_group(settings: &State<Settings>, cookie: SessionCookie, group_id: String, member_id: String) -> Result<(), Json<ApiErrorWrapper>>{
     let caller = parse_member_cookie(cookie.member)?;
     let member_id = parse_uuid_string(member_id)?;
     let group_id = parse_uuid_string(group_id)?;
 
-    if !check_access_to_resource(&settings, caller.entity_id, group_id, crate::permissions::modules::member_management::groups::members::EDIT){
+    if !check_access_to_resource(settings, caller.entity_id, group_id, crate::permissions::modules::member_management::groups::members::EDIT){
         return Err(Json(ApiError::new(403, "Keine Berechtigung Gruppenmitglieder zu ändern!".to_string()).to_wrapper()))
     }
 
-    match remove_member_from_group(&settings, member_id, group_id){
+    match remove_member_from_group(settings, member_id, group_id){
         Ok(_) => Ok(()),
         Err(e) => Err(translate_diesel(e))
     }

src/modules/api/groups/read.rs

@@ -12,7 +12,7 @@ use crate::modules::api::members::get_member::MemberSearchResult;
 use crate::modules::api::model::api_outcome::{ApiError, ApiErrorWrapper};
 
 use rocket::State;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 
 #[derive(Serialize, Deserialize, Queryable, Clone)]
 pub struct CallerGroupPermissions {
@@ -41,13 +41,13 @@ pub struct GetGroupsResult{
 /// Filters:
 /// * with_caller_permission (String): Only show groups where caller has permission x
 #[get("/api/groups?<with_caller_permission>", format = "json")]
-pub fn get_groups(settings: State<Settings>, cookie: SessionCookie, with_caller_permission: Option<String>) -> Result<Json<GetGroupsResult>, Json<ApiErrorWrapper>>{
+pub fn get_groups(settings: &State<Settings>, cookie: SessionCookie, with_caller_permission: Option<String>) -> Result<Json<GetGroupsResult>, Json<ApiErrorWrapper>>{
     let caller = parse_member_cookie(cookie.member)?;
     if !caller.has_permission(crate::permissions::modules::member_management::groups::VIEW.to_string()) {
         return Err(Json(ApiError::new(403, "Keine Berechtigung, Gruppen abzurufen!".to_string()).to_wrapper()));
     }
 
-    let groups = match get_raw_groups(&settings){
+    let groups = match get_raw_groups(settings){
         Ok(groups) => groups,
         Err(e) => return Err(translate_diesel(e))
     };
@@ -57,7 +57,7 @@ pub fn get_groups(settings: State<Settings>, cookie: SessionCookie, with_caller_
     for group in groups{
         match &with_caller_permission {
             Some(caller_permission) => {
-                if check_access_to_resource(&settings, caller.entity_id, group.group_id, &caller_permission){
+                if check_access_to_resource(settings, caller.entity_id, group.group_id, &caller_permission){
                     groups_with_permission.push(group);
                 }
             },
@@ -78,7 +78,7 @@ pub fn get_groups(settings: State<Settings>, cookie: SessionCookie, with_caller_
 /// Get detailed group
 #[get("/api/groups/<entity_id>?detailed", format = "json")]
 pub fn read_group_detailed(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     entity_id: String,
 ) -> Result<Json<DetailedGroup>, Json<ApiErrorWrapper>> {
@@ -136,17 +136,17 @@ pub fn read_group_detailed(
         ),
     };
 
-    let group = match get_group(&settings, entity_id) {
+    let group = match get_group(settings, entity_id) {
         Ok(group) => group,
         Err(e) => return Err(translate_diesel(e)),
     };
 
-    let members = match get_member_search_results_in_group(&settings, entity_id, caller.entity_id) {
+    let members = match get_member_search_results_in_group(settings, entity_id, caller.entity_id) {
         Ok(members) => members,
         Err(e) => return Err(translate_diesel(e)),
     };
 
-    let group_role_permissions = match get_group_role_permissions(&settings, group.group_id) {
+    let group_role_permissions = match get_group_role_permissions(settings, group.group_id) {
         Ok(grp) => grp,
         Err(e) => return Err(translate_diesel(e)),
     };
@@ -174,14 +174,14 @@ pub fn read_group_detailed(
 /// Get group simple mode (only name, description, entity_id)
 #[get("/api/groups/<entity_id>", format = "json")]
 pub fn read_group_simple(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     entity_id: String,
 ) -> Result<Json<RawGroup>, Json<ApiErrorWrapper>> {
     let _caller = parse_member_cookie(cookie.member)?;
     let entity_id = parse_uuid_string(entity_id)?;
 
-    let group = match get_group(&settings, entity_id) {
+    let group = match get_group(settings, entity_id) {
         Ok(group) => group,
         Err(e) => return Err(translate_diesel(e)),
     };

src/modules/api/groups/update.rs

@@ -3,7 +3,7 @@ use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::database::controller::members_groups::add_member_to_group;
 use crate::helper::translate_diesel_error::translate_diesel;
 use crate::database::controller::members::check_access_to_resource;
@@ -11,31 +11,31 @@ use crate::modules::member_management::model::groups::{GroupUpdateData};
 use crate::database::controller::groups::update_group_core_data;
 
 #[put("/api/groups/<group_id>/members/<member_id>", format = "json")]
-pub fn put_member_in_group(settings: State<Settings>, cookie: SessionCookie, group_id: String, member_id: String) -> Result<(), Json<ApiErrorWrapper>>{
+pub fn put_member_in_group(settings: &State<Settings>, cookie: SessionCookie, group_id: String, member_id: String) -> Result<(), Json<ApiErrorWrapper>>{
     let caller = parse_member_cookie(cookie.member)?;
     let member_id = parse_uuid_string(member_id)?;
     let group_id = parse_uuid_string(group_id)?;
 
-    if !check_access_to_resource(&settings, caller.entity_id, group_id, crate::permissions::modules::member_management::groups::members::EDIT){
+    if !check_access_to_resource(settings, caller.entity_id, group_id, crate::permissions::modules::member_management::groups::members::EDIT){
         return Err(Json(ApiError::new(403, "Keine Berechtigung Gruppenmitglieder zu ändern!".to_string()).to_wrapper()))
     }
 
-    match add_member_to_group(&settings, member_id, group_id){
+    match add_member_to_group(settings, member_id, group_id){
         Ok(_) => Ok(()),
         Err(e) => Err(translate_diesel(e))
     }
 }
 
 #[put("/api/groups/<group_id>", format = "json", data = "<update_group_data>")]
-pub fn update_group(settings: State<Settings>, cookie: SessionCookie, update_group_data: Json<GroupUpdateData>, group_id: String) -> Result<(), Json<ApiErrorWrapper>>{
+pub fn update_group(settings: &State<Settings>, cookie: SessionCookie, update_group_data: Json<GroupUpdateData>, group_id: String) -> Result<(), Json<ApiErrorWrapper>>{
     let caller = parse_member_cookie(cookie.member)?;
     let group_id = parse_uuid_string(group_id)?;
 
-    if !check_access_to_resource(&settings, caller.entity_id, group_id, crate::permissions::modules::member_management::groups::core::EDIT){
+    if !check_access_to_resource(settings, caller.entity_id, group_id, crate::permissions::modules::member_management::groups::core::EDIT){
         return Err(Json(ApiError::new(403, "Keine Berechtigung Gruppe zu ändern!".to_string()).to_wrapper()))
     }
 
-    match update_group_core_data(&settings, group_id, update_group_data.into_inner()){
+    match update_group_core_data(settings, group_id, update_group_data.into_inner()){
         Ok(_) => Ok(()),
         Err(e) => Err(translate_diesel(e))
     }

src/modules/api/info/caller.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::ApiErrorWrapper;
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 
@@ -20,7 +20,7 @@ use crate::database::controller::members::check_access_to_resource;
 /// * None
 #[get("/api/info/caller/permissions?<permission>&<entity_id>", format = "json")]
 pub fn check_caller_has_permission(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     permission: String,
     entity_id: Option<String>,
@@ -30,7 +30,7 @@ pub fn check_caller_has_permission(
     match entity_id{
         Some(entity_id) => {
             let entity_id = parse_uuid_string(entity_id)?;
-            Ok(Json(check_access_to_resource(&settings, caller.entity_id, entity_id, &permission)))
+            Ok(Json(check_access_to_resource(settings, caller.entity_id, entity_id, &permission)))
         },
         None => {
             Ok(Json(caller.has_permission(permission)))

src/modules/api/member_management/controller/member_driving_permissions.rs

@@ -4,7 +4,7 @@ use crate::database::controller::member_licenses::{
 use crate::helper::settings::Settings;
 use crate::modules::api::model::api_outcome::{ApiError, ApiErrorWrapper};
 use rocket::State;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 
 pub fn add_member_license_or_error(
     member_id: uuid::Uuid,

src/modules/api/member_management/controller/member_qualifications.rs

@@ -1,5 +1,5 @@
 use crate::modules::api::model::api_outcome::{ApiError, ApiErrorWrapper};
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use std::str::FromStr;
 
 pub fn parse_qualification_id(

src/modules/api/member_management/controller/parser.rs

@@ -3,7 +3,7 @@ use crate::helper::settings::Settings;
 use crate::modules::api::model::api_outcome::{ApiError, ApiErrorWrapper};
 use crate::modules::member_management::model::member::Member;
 use rocket::State;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use std::str::FromStr;
 
 pub fn parse_uuid_string(entity_id: String) -> Result<uuid::Uuid, Json<ApiErrorWrapper>> {

src/modules/api/member_management/view/member_driving_permissions.rs

@@ -10,7 +10,7 @@ use crate::modules::api::member_management::controller::parser::{
 };
 use crate::modules::api::model::api_outcome::{ApiError, ApiErrorWrapper};
 use rocket::State;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 
 #[put(
     "/api/member_management/add_driving_license?<member_id>&<license_name>",
@@ -18,7 +18,7 @@ use rocket_contrib::json::Json;
 )]
 pub fn api_member_add_driving_license(
     cookie: SessionCookie,
-    settings: State<Settings>,
+    settings: &State<Settings>,
     member_id: String,
     license_name: String,
 ) -> Result<(), Json<ApiErrorWrapper>> {
@@ -43,7 +43,7 @@ pub fn api_member_add_driving_license(
 )]
 pub fn api_member_add_driving_permission(
     cookie: SessionCookie,
-    settings: State<Settings>,
+    settings: &State<Settings>,
     member_id: String,
     license_name: String,
 ) -> Result<(), Json<ApiErrorWrapper>> {
@@ -68,7 +68,7 @@ pub fn api_member_add_driving_permission(
 )]
 pub fn api_member_remove_driving_license(
     cookie: SessionCookie,
-    settings: State<Settings>,
+    settings: &State<Settings>,
     member_id: String,
     license_name: String,
 ) -> Result<(), Json<ApiErrorWrapper>> {

src/modules/api/member_management/view/member_qualifications.rs

@@ -11,7 +11,7 @@ use crate::modules::api::member_management::controller::parser::{parse_member_co
 use crate::modules::api::model::api_outcome::{ApiError, ApiErrorWrapper};
 use crate::modules::member_management::model::qualifications::{Qualification};
 use rocket::State;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 
 #[get(
     "/api/member_management/get_qualifications_for_category?<category_id>",
@@ -19,7 +19,7 @@ use rocket_contrib::json::Json;
 )]
 pub fn api_member_get_qualifications_for_category(
     cookie: SessionCookie,
-    settings: State<Settings>,
+    settings: &State<Settings>,
     category_id: String,
 ) -> Result<Json<Vec<Qualification>>, Json<ApiErrorWrapper>> {
     //TODO: Check permissions!
@@ -27,7 +27,7 @@ pub fn api_member_get_qualifications_for_category(
     let category_id = parse_category_id(category_id)?;
 
     //TODO: Proper error handling/display
-    let categories = get_qualifications_for_category(&settings, category_id);
+    let categories = get_qualifications_for_category(settings, category_id);
     Ok(Json(categories))
 }
 
@@ -37,7 +37,7 @@ pub fn api_member_get_qualifications_for_category(
 )]
 pub fn api_member_remove_qualification(
     _cookie: SessionCookie,
-    settings: State<Settings>,
+    settings: &State<Settings>,
     member_id: String,
     qualification_id: String,
 ) -> Result<(), Json<ApiErrorWrapper>> {
@@ -45,7 +45,7 @@ pub fn api_member_remove_qualification(
     let member_id = parse_uuid_string(member_id)?;
     let qualification_id = parse_qualification_id(qualification_id)?;
 
-    match remove_qualification_for_member(&settings, member_id, qualification_id) {
+    match remove_qualification_for_member(settings, member_id, qualification_id) {
         Ok(_) => Ok(()),
         Err(_) => {
             return Err(Json(
@@ -63,7 +63,7 @@ pub fn api_member_remove_qualification(
 )]
 pub fn api_member_add_qualification(
     _cookie: SessionCookie,
-    settings: State<Settings>,
+    settings: &State<Settings>,
     member_id: String,
     qualification_id: String,
 ) -> Result<(), Json<ApiErrorWrapper>> {
@@ -71,7 +71,7 @@ pub fn api_member_add_qualification(
     let member_id = parse_uuid_string(member_id)?;
     let qualification_id = parse_qualification_id(qualification_id)?;
 
-    match add_qualification_for_member(&settings, member_id, qualification_id) {
+    match add_qualification_for_member(settings, member_id, qualification_id) {
         Ok(_) => Ok(()),
         Err(_) => {
             return Err(Json(

src/modules/api/members/delete_member.rs

@@ -7,17 +7,17 @@ use crate::modules::api::member_management::controller::parser::{parse_member_co
 
 use crate::modules::api::model::api_outcome::{ApiError, ApiErrorWrapper};
 use rocket::State;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 
 #[delete("/api/members/<entity_id>", format = "json")]
 pub fn api_members_delete(
     cookie: SessionCookie,
-    settings: State<Settings>,
+    settings: &State<Settings>,
     entity_id: String,
 ) -> Result<(), Json<ApiErrorWrapper>> {
     let caller = parse_member_cookie(cookie.member)?;
     let member_id = parse_uuid_string(entity_id)?;
-    let groups = get_groups_for_member(&settings, member_id);
+    let groups = get_groups_for_member(settings, member_id);
 
     if !check_access_to_member_and_group(
         &settings,
@@ -31,7 +31,7 @@ pub fn api_members_delete(
         ));
     }
 
-    match delete_entity_deprecated(&settings, member_id) {
+    match delete_entity_deprecated(settings, member_id) {
         Ok(result) => {
             if result == 1 {
                 Ok(())

src/modules/api/members/get_member.rs

@@ -6,7 +6,7 @@ use crate::helper::settings::Settings;
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 use crate::modules::api::model::api_outcome::{ApiError, ApiErrorWrapper};
 use rocket::State;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 
 #[derive(Serialize, Deserialize, Queryable, Clone)]
 pub struct MemberSearchResult {
@@ -24,7 +24,7 @@ pub struct MemberSearch {
 #[get("/api/members/<entity_id>", format = "json", rank = 1)]
 pub fn api_members_get(
     cookie: SessionCookie,
-    settings: State<Settings>,
+    settings: &State<Settings>,
     entity_id: String,
 ) -> Result<Json<MemberSearchResult>, Json<ApiErrorWrapper>> {
     let caller = parse_member_cookie(cookie.member)?;
@@ -36,7 +36,7 @@ pub fn api_members_get(
     };
 
     let entity_id = parse_uuid_string(entity_id)?;
-    match get_member_search_result(&settings, entity_id, caller.entity_id) {
+    match get_member_search_result(settings, entity_id, caller.entity_id) {
         Ok(result) => Ok(Json(result)),
         Err(e) => match e {
             diesel::result::Error::NotFound => Err(Json(
@@ -57,7 +57,7 @@ pub fn api_members_get(
 #[get("/api/members?<name>", format = "json", rank = 2)]
 pub fn api_members_search_name(
     cookie: SessionCookie,
-    settings: State<Settings>,
+    settings: &State<Settings>,
     name: String,
 ) -> Result<Json<MemberSearch>, Json<ApiErrorWrapper>> {
     let caller = parse_member_cookie(cookie.member)?;
@@ -68,7 +68,7 @@ pub fn api_members_search_name(
         ));
     };
 
-    match get_member_search_result_by_name(&settings, name, caller.entity_id) {
+    match get_member_search_result_by_name(settings, name, caller.entity_id) {
         Ok(result) => Ok(Json(MemberSearch { members: result })),
         Err(e) => match e {
             diesel::result::Error::NotFound => Err(Json(

src/modules/api/members/licenses/read.rs

@@ -1,7 +1,7 @@
 use crate::helper::session_cookies::model::SessionCookie;
 use crate::helper::settings::Settings;
 use rocket::State;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::database::model::member_licenses::LicenseCategory;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper};
 use crate::modules::api::member_management::controller::parser::parse_member_cookie;
@@ -14,11 +14,11 @@ format = "json"
 )]
 pub fn read_license_categories(
     cookie: SessionCookie,
-    settings: State<Settings>,
+    settings: &State<Settings>,
 ) -> Result<Json<Vec<LicenseCategory>>, Json<ApiErrorWrapper>> {
     let _caller = parse_member_cookie(cookie.member)?;
 
-    match get_license_categories(&settings){
+    match get_license_categories(settings){
         Ok(licenses) => Ok(Json(licenses)),
         Err(e) => Err(translate_diesel(e))
     }

src/modules/api/members/member_communication.rs

@@ -7,7 +7,7 @@ use crate::schema::communication_targets;
 
 
 use rocket::State;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::helper::check_access::check_access_to_member_and_group;
 use crate::database::controller::groups::get_groups_for_member;
 use crate::database::controller::member_communication::{get_communication_target, add_communication_target, remove_communication_target};
@@ -25,7 +25,7 @@ pub struct CommunicationTarget {
 }
 
 #[get("/api/communication_types", format="json")]
-pub fn api_communication_types_get(settings: State<Settings>, cookie: SessionCookie) -> Result<Json<CommunicationTypeList>, Json<ApiErrorWrapper>>{
+pub fn api_communication_types_get(settings: &State<Settings>, cookie: SessionCookie) -> Result<Json<CommunicationTypeList>, Json<ApiErrorWrapper>>{
     let caller = parse_member_cookie(cookie.member)?;
     if !caller.has_permission(crate::permissions::modules::configuration::fields::communication_types::VIEW.to_string()) {
         return Err(Json(
@@ -36,7 +36,7 @@ pub fn api_communication_types_get(settings: State<Settings>, cookie: SessionCoo
                 .to_wrapper(),
         ));
     }
-    let type_list = get_member_communication_types(&settings);
+    let type_list = get_member_communication_types(settings);
     match type_list{
         Ok(list) => Ok(Json(CommunicationTypeList{ types: list })),
         Err(e) => {
@@ -52,18 +52,18 @@ format = "json"
 )]
 pub fn api_communication_targets_create(
     cookie: SessionCookie,
-    settings: State<Settings>,
+    settings: &State<Settings>,
     communication_target: Json<CommunicationTargetCreate>,
 ) -> Result<Json<CommunicationTargetId>, Json<ApiErrorWrapper>> {
     let caller = parse_member_cookie(cookie.member)?;
     let communication_target = communication_target.into_inner();
 
-    let groups = get_groups_for_member(&settings, communication_target.entity_id);
+    let groups = get_groups_for_member(settings, communication_target.entity_id);
-    if !check_access_to_member_and_group(&settings, communication_target.entity_id, groups, caller.entity_id, crate::permissions::modules::member_management::profile::communication::EDIT.to_string()){
+    if !check_access_to_member_and_group(settings, communication_target.entity_id, groups, caller.entity_id, crate::permissions::modules::member_management::profile::communication::EDIT.to_string()){
         return Err(Json(ApiError::new(401, "Keine Berechtigung, ein Kommunikationsziel hinzuzufügen.".to_string()).to_wrapper()))
     }
 
-    match add_communication_target(&settings, communication_target) {
+    match add_communication_target(settings, communication_target) {
         Ok(target_id) => Ok(Json(CommunicationTargetId { target_id })),
         Err(e) => Err(translate_diesel(e)
         ),
@@ -76,7 +76,7 @@ pub fn api_communication_targets_create(
     data = "<communication_target>"
 )]
 pub fn api_communication_targets_update(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     target_id: String,
     communication_target: Json<CommunicationTarget>,
@@ -84,15 +84,15 @@ pub fn api_communication_targets_update(
     let caller = parse_member_cookie(cookie.member)?;
     let target_id = parse_uuid_string(target_id)?;
 
-    let old_target = match get_communication_target(&settings, target_id){
+    let old_target = match get_communication_target(settings, target_id){
         Ok(target) => target,
         Err(e) => return Err(translate_diesel(e))
     };
 
-    let member_groups = get_groups_for_member(&settings, old_target.entity_id);
+    let member_groups = get_groups_for_member(settings, old_target.entity_id);
 
     if old_target.entity_id != caller.entity_id{ //if Member edits own communication target, do not check permissions
-     if !check_access_to_member_and_group(&settings, old_target.entity_id, member_groups, caller.entity_id, "modules.member_management.profile.communication.edit".to_string()) {
+     if !check_access_to_member_and_group(settings, old_target.entity_id, member_groups, caller.entity_id, "modules.member_management.profile.communication.edit".to_string()) {
          return Err(Json(
              ApiError::new(
                  403,
@@ -120,7 +120,7 @@ pub fn api_communication_targets_update(
         None => {}
     }
 
-    match update_communication_target(&settings, target_id, communication_target) {
+    match update_communication_target(settings, target_id, communication_target) {
         Ok(result) => {
             if result == 1 {
                 Ok(())
@@ -153,26 +153,26 @@ format = "json"
 )]
 pub fn api_communication_targets_delete(
     cookie: SessionCookie,
-    settings: State<Settings>,
+    settings: &State<Settings>,
     target_id: String,
 ) -> Result<(), Json<ApiErrorWrapper>> {
     let member = parse_member_cookie(cookie.member)?;
     let target_id = parse_uuid_string(target_id)?;
 
-    let target = match get_communication_target(&settings, target_id){
+    let target = match get_communication_target(settings, target_id){
         Ok(target) => target,
         Err(e) => {
             return Err(translate_diesel(e))
         }
     };
 
-    let groups = get_groups_for_member(&settings, target.entity_id);
+    let groups = get_groups_for_member(settings, target.entity_id);
 
-    if !check_access_to_member_and_group(&settings, target.entity_id, groups, member.entity_id, crate::permissions::modules::member_management::profile::communication::EDIT.to_string()){
+    if !check_access_to_member_and_group(settings, target.entity_id, groups, member.entity_id, crate::permissions::modules::member_management::profile::communication::EDIT.to_string()){
         return Err(Json(ApiError::new(401, "Keine Berechtigung Kommunikationseintrag zu löschen!".to_string()).to_wrapper()))
     }
 
-    match remove_communication_target(&settings, target_id) {
+    match remove_communication_target(settings, target_id) {
         Ok(_) => Ok(()),
         Err(_) => Err(Json(
             ApiError::new(500, "Datenbankfehler aufgetreten".to_string()).to_wrapper(),

src/modules/api/members/member_qualification.rs

@@ -1,7 +1,7 @@
 use crate::helper::session_cookies::model::SessionCookie;
 use rocket::State;
 use crate::helper::settings::Settings;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::member_management::model::qualifications::{QualificationList, QualificationCategory};
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
@@ -16,20 +16,20 @@ format = "json"
 )]
 pub fn api_member_qualifications_read(
     cookie: SessionCookie,
-    settings: State<Settings>,
+    settings: &State<Settings>,
     member_id: String,
 ) -> Result<Json<QualificationList>, Json<ApiErrorWrapper>> {
     let caller = parse_member_cookie(cookie.member)?;
     let member_id = parse_uuid_string(member_id)?;
 
-    let groups = get_groups_for_member(&settings, member_id);
+    let groups = get_groups_for_member(settings, member_id);
 
-    if !check_access_to_member_and_group(&settings, member_id, groups, caller.entity_id, crate::permissions::modules::member_management::profile::qualifications::VIEW.to_string()){
+    if !check_access_to_member_and_group(settings, member_id, groups, caller.entity_id, crate::permissions::modules::member_management::profile::qualifications::VIEW.to_string()){
         return Err(Json(ApiError::new(401, "Keine Berechtigung Qualifikationen für dieses Mitglied abzurufen!".to_string()).to_wrapper()))
     }
 
     //TODO: Proper error handling/display
-    let categories = get_qualifcation_categories(&settings, member_id);
+    let categories = get_qualifcation_categories(settings, member_id);
     Ok(Json(QualificationList { categories }))
 }
 
@@ -39,11 +39,11 @@ format = "json"
 )]
 pub fn read_qualifications(
     cookie: SessionCookie,
-    settings: State<Settings>,
+    settings: &State<Settings>,
 ) -> Result<Json<Vec<QualificationCategory>>, Json<ApiErrorWrapper>> {
     let _caller = parse_member_cookie(cookie.member)?;
 
-    match get_qualifications(&settings){
+    match get_qualifications(settings){
         Ok(qual) => Ok(Json(qual)),
         Err(e) => Err(translate_diesel(e))
     }

src/modules/api/resources/vehicles/create.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 
 use crate::database::model::vehicles::Vehicle;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
@@ -25,7 +25,7 @@ pub struct CreateVehicleData{
 
 #[post("/api/resources/vehicles", format = "json", data = "<create_vehicle_data>")]
 pub fn create_vehicle(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     create_vehicle_data: Json<CreateVehicleData>,
 ) -> Result<Json<Vehicle>, Json<ApiErrorWrapper>> {
@@ -38,7 +38,7 @@ pub fn create_vehicle(
 
     let vehicle_create_data = create_vehicle_data.into_inner();
 
-    let entity_id2 = match generate_entity(&settings){
+    let entity_id2 = match generate_entity(settings){
         Ok(ent) => ent,
         Err(_e) => return Err(Json(ApiError::new(500, "Konnte keine neue Entität anlegen!".to_string()).to_wrapper()))
     };
@@ -59,37 +59,37 @@ pub fn create_vehicle(
         vehicle_category,
     };
 
-    match add_vehicle(&settings, vehicle){
+    match add_vehicle(settings, vehicle){
         Ok(vehicle) => {
-            let rpi = match get_role_permission_id(&settings, "admin".to_string(), crate::permissions::modules::resource_management::vehicles::core::EDIT){
+            let rpi = match get_role_permission_id(settings, "admin".to_string(), crate::permissions::modules::resource_management::vehicles::core::EDIT){
                 Some(rpi) => rpi,
                 None => return Err(Json(ApiError::new(500, "Couldn't add permission".to_string()).to_wrapper()))
             };
-            let rpi2 = match get_role_permission_id(&settings, "admin".to_string(), crate::permissions::modules::scheduler::appointments::VIEW){
+            let rpi2 = match get_role_permission_id(settings, "admin".to_string(), crate::permissions::modules::scheduler::appointments::VIEW){
                 Some(rpi) => rpi,
                 None => return Err(Json(ApiError::new(500, "Couldn't add permission".to_string()).to_wrapper()))
             };
-            let rpi3 = match get_role_permission_id(&settings, "admin".to_string(), crate::permissions::modules::scheduler::appointments::EDIT){
+            let rpi3 = match get_role_permission_id(settings, "admin".to_string(), crate::permissions::modules::scheduler::appointments::EDIT){
                 Some(rpi) => rpi,
                 None => return Err(Json(ApiError::new(500, "Couldn't add permission".to_string()).to_wrapper()))
             };
-            let rpi4 = match get_role_permission_id(&settings, "admin".to_string(), crate::permissions::modules::resource_management::vehicles::core::DELETE){
+            let rpi4 = match get_role_permission_id(settings, "admin".to_string(), crate::permissions::modules::resource_management::vehicles::core::DELETE){
                 Some(rpi) => rpi,
                 None => return Err(Json(ApiError::new(500, "Couldn't add permission".to_string()).to_wrapper()))
             };
-            match add_permission_context(&settings, rpi, vehicle.entity_id){
+            match add_permission_context(settings, rpi, vehicle.entity_id){
                 Ok(_) => {},
                 Err(e) => return Err(translate_diesel(e))
             };
-            match add_permission_context(&settings, rpi3, vehicle.entity_id){
+            match add_permission_context(settings, rpi3, vehicle.entity_id){
                 Ok(_) => {},
                 Err(e) => return Err(translate_diesel(e))
             };
-            match add_permission_context(&settings, rpi2, vehicle.entity_id){
+            match add_permission_context(settings, rpi2, vehicle.entity_id){
                 Ok(_) => {},
                 Err(e) => return Err(translate_diesel(e))
             };
-            match add_permission_context(&settings, rpi4, vehicle.entity_id){
+            match add_permission_context(settings, rpi4, vehicle.entity_id){
                 Ok(_) => Ok(Json(vehicle)),
                 Err(e) => Err(translate_diesel(e))
             }

src/modules/api/resources/vehicles/delete.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::parse_member_cookie;
 use crate::database::controller::members::check_access_to_resource;
@@ -10,7 +10,7 @@ use crate::database::controller::api_members::delete_entity_deprecated;
 
 #[delete("/api/resources/vehicles", format = "json", data = "<vehicle_list>")]
 pub fn delete_vehicles(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     vehicle_list: Json<Vec<uuid::Uuid>>,
 ) -> Result<(), Json<ApiErrorWrapper>> {
@@ -28,7 +28,7 @@ pub fn delete_vehicles(
             vehicle,
             crate::permissions::modules::resource_management::vehicles::core::DELETE,
         ) {
-            match delete_entity_deprecated(&settings, vehicle){
+            match delete_entity_deprecated(settings, vehicle){
                 Ok(_) => {}
                 Err(e) => return Err(translate_diesel(e)),
             }

src/modules/api/resources/vehicles/read.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::database::model::vehicles::{VehicleCategory, Vehicle};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
@@ -11,11 +11,11 @@ use crate::helper::translate_diesel_error::translate_diesel;
 
 #[get("/api/resources/vehicles/categories", format = "json")]
 pub fn read_vehicle_categories(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
 ) -> Result<Json<Vec<VehicleCategory>>, Json<ApiErrorWrapper>> {
     parse_member_cookie(cookie.member)?;
-    match get_vehicle_categories(&settings){
+    match get_vehicle_categories(settings){
         Ok(category) => Ok(Json(category)),
         Err(e) => Err(translate_diesel(e))
     }
@@ -29,7 +29,7 @@ pub struct VehicleList{
 
 #[get("/api/resources/vehicles?<entries>&<page>&<q>", format = "json")]
 pub fn read_vehicle_list(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     entries: Option<i64>,
     page: Option<i64>,
@@ -70,12 +70,12 @@ pub fn read_vehicle_list(
         total_vehicle_count: 0
     };
 
-    match get_vehicles(&settings, entries, (page-1)*entries, q){
+    match get_vehicles(settings, entries, (page-1)*entries, q){
         Ok(vehicles) => res.vehicle_list = vehicles,
         Err(e) => return Err(translate_diesel(e))
     };
 
-    match get_vehicle_count(&settings){
+    match get_vehicle_count(settings){
         Ok(count) => res.total_vehicle_count = count,
         Err(e) => return Err(translate_diesel(e))
     };
@@ -85,7 +85,7 @@ pub fn read_vehicle_list(
 
 #[get("/api/resources/vehicles/<entity_id>", format = "json")]
 pub fn read_vehicle(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     entity_id: String,
 ) -> Result<Json<Vehicle>, Json<ApiErrorWrapper>> {
@@ -95,7 +95,7 @@ pub fn read_vehicle(
         return Err(Json(ApiError::new(403, "Keine Berechtigung Fahrzeugliste abzurufen!".to_string()).to_wrapper()))
     }
 
-    match get_vehicle(&settings, parse_uuid_string(entity_id)?){
+    match get_vehicle(settings, parse_uuid_string(entity_id)?){
         Ok(vehicle) => Ok(Json(vehicle)),
         Err(e) => Err(translate_diesel(e))
     }

src/modules/api/resources/vehicles/update.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::resources::vehicles::create::CreateVehicleData;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
@@ -15,7 +15,7 @@ use crate::database::controller::members::check_access_to_resource;
 
 #[put("/api/resources/vehicles/<vehicle_id>", format = "json", data = "<change_vehicle_data>")]
 pub fn update_vehicle(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     change_vehicle_data: Json<CreateVehicleData>,
     vehicle_id: String,
@@ -23,7 +23,7 @@ pub fn update_vehicle(
     let caller = parse_member_cookie(cookie.clone().member)?;
     let vehicle_id = parse_uuid_string(vehicle_id)?;
 
-    if !check_access_to_resource(&settings, caller.entity_id, vehicle_id, crate::permissions::modules::resource_management::vehicles::core::EDIT){
+    if !check_access_to_resource(settings, caller.entity_id, vehicle_id, crate::permissions::modules::resource_management::vehicles::core::EDIT){
         return Err(Json(
             ApiError::new(403, "Keine Berechtigung, Fahrzeuge zu ändern!".to_string()).to_wrapper(),
         ));
@@ -48,7 +48,7 @@ pub fn update_vehicle(
         vehicle_category,
     };
 
-    match change_vehicle(&settings, vehicle){
+    match change_vehicle(settings, vehicle){
         Ok(_) => Ok(()),
         Err(e) => Err(translate_diesel(e))
     }

src/modules/api/units/delete.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 use crate::database::controller::members::check_access_to_resource;
@@ -9,16 +9,16 @@ use crate::database::controller::units_members::remove_member_from_unit;
 use crate::helper::translate_diesel_error::translate_diesel;
 
 #[delete("/api/units/<unit_id>/members/<member_id>", format = "json")]
-pub fn delete_member_from_unit(settings: State<Settings>, cookie: SessionCookie, unit_id: String, member_id: String) -> Result<(), Json<ApiErrorWrapper>>{
+pub fn delete_member_from_unit(settings: &State<Settings>, cookie: SessionCookie, unit_id: String, member_id: String) -> Result<(), Json<ApiErrorWrapper>>{
     let caller = parse_member_cookie(cookie.member)?;
     let _member_id = parse_uuid_string(member_id)?;
     let unit_id = parse_uuid_string(unit_id)?;
 
-    if !check_access_to_resource(&settings, caller.entity_id, unit_id, crate::permissions::modules::units::members::EDIT){
+    if !check_access_to_resource(settings, caller.entity_id, unit_id, crate::permissions::modules::units::members::EDIT){
         return Err(Json(ApiError::new(403, "Keine Berechtigung Einheitenmitglieder zu ändern!".to_string()).to_wrapper()))
     }
 
-    match remove_member_from_unit(&settings, unit_id){
+    match remove_member_from_unit(settings, unit_id){
         Ok(_) => Ok(()),
         Err(e) => Err(translate_diesel(e))
     }

src/modules/api/units/read.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::ApiErrorWrapper;
 use crate::database::model::units::RawUnit;
 use crate::modules::api::member_management::controller::parser::parse_member_cookie;
@@ -11,13 +11,13 @@ use crate::helper::translate_diesel_error::translate_diesel;
 
 #[get("/api/units?<with_caller_permission>", format = "json")]
 pub fn read_unit_list(
-    settings: State<Settings>,
+    settings: &State<Settings>,
     cookie: SessionCookie,
     with_caller_permission: Option<String>
 ) -> Result<Json<Vec<RawUnit>>, Json<ApiErrorWrapper>> {
     let caller = parse_member_cookie(cookie.member)?;
 
-    let units = match get_units(&settings){
+    let units = match get_units(settings){
         Ok(units) => units,
         Err(e) => return Err(translate_diesel(e))
     };
@@ -27,7 +27,7 @@ pub fn read_unit_list(
         Some(permission) => {
             let mut unit_list : Vec<RawUnit> = vec![];
             for unit in units{
-                if check_access_to_resource(&settings, caller.entity_id, unit.unit_id, &permission){
+                if check_access_to_resource(settings, caller.entity_id, unit.unit_id, &permission){
                     unit_list.push(unit);
                 }
             }

src/modules/api/units/update.rs

@@ -1,7 +1,7 @@
 use rocket::State;
 use crate::helper::settings::Settings;
 use crate::helper::session_cookies::model::SessionCookie;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 use crate::database::controller::members::check_access_to_resource;
@@ -9,16 +9,16 @@ use crate::database::controller::units_members::add_member_to_unit;
 use crate::helper::translate_diesel_error::translate_diesel;
 
 #[put("/api/units/<unit_id>/members/<member_id>?<crew>", format = "json")]
-pub fn put_member_in_unit(settings: State<Settings>, cookie: SessionCookie, unit_id: String, member_id: String, crew: i16) -> Result<(), Json<ApiErrorWrapper>>{
+pub fn put_member_in_unit(settings: &State<Settings>, cookie: SessionCookie, unit_id: String, member_id: String, crew: i16) -> Result<(), Json<ApiErrorWrapper>>{
     let caller = parse_member_cookie(cookie.member)?;
     let member_id = parse_uuid_string(member_id)?;
     let unit_id = parse_uuid_string(unit_id)?;
 
-    if !check_access_to_resource(&settings, caller.entity_id, unit_id, crate::permissions::modules::units::members::EDIT){
+    if !check_access_to_resource(settings, caller.entity_id, unit_id, crate::permissions::modules::units::members::EDIT){
         return Err(Json(ApiError::new(403, "Keine Berechtigung Einheitsmitglieder zu ändern!".to_string()).to_wrapper()))
     }
 
-    match add_member_to_unit(&settings, member_id, unit_id, crew){
+    match add_member_to_unit(settings, member_id, unit_id, crew){
         Ok(_) => Ok(()),
         Err(e) => Err(translate_diesel(e))
     }

src/modules/api/users/create.rs

@@ -3,7 +3,7 @@ use rocket::State;
 use crate::helper::session_cookies::model::SessionCookie;
 use crate::modules::member_management::model::login::Login;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::member_management::controller::parser::parse_member_cookie;
 use crate::helper::check_access::check_access_to_member_and_group;
 use crate::database::controller::groups::get_groups_for_member;
@@ -17,19 +17,19 @@ pub struct CreateUserData{
 }
 
 #[post("/api/users", format = "json", data = "<create_user_data>")]
-pub fn create_user(settings: State<Settings>, cookie: SessionCookie, create_user_data: Json<CreateUserData>) -> Result<Json<Login>, Json<ApiErrorWrapper>>{
+pub fn create_user(settings: &State<Settings>, cookie: SessionCookie, create_user_data: Json<CreateUserData>) -> Result<Json<Login>, Json<ApiErrorWrapper>>{
     let caller = parse_member_cookie(cookie.member)?;
 
     let data = create_user_data.into_inner();
-    let member_groups = get_groups_for_member(&settings, data.member_id);
+    let member_groups = get_groups_for_member(settings, data.member_id);
 
     if caller.entity_id != data.member_id { //Skip permission check if user edits own login
-        if !check_access_to_member_and_group(&settings, data.member_id, member_groups, caller.entity_id, "modules.member_management.profile.login.edit".to_string()) {
+        if !check_access_to_member_and_group(settings, data.member_id, member_groups, caller.entity_id, "modules.member_management.profile.login.edit".to_string()) {
             return Err(Json(ApiError::new(401, "Keine Rechte Login für dieses Mitglied anzulegen!".to_string()).to_wrapper()))
         }
     }
 
-    match add_user_to_member(&settings, data.member_id, data.email){
+    match add_user_to_member(settings, data.member_id, data.email){
         Ok(user) => Ok(Json(Login{
             user_id: Some(user.id),
             email: Some(user.email.to_lowercase()),

src/modules/api/users/delete.rs

@@ -2,7 +2,7 @@ use crate::helper::settings::Settings;
 use rocket::State;
 use crate::helper::session_cookies::model::SessionCookie;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 use crate::helper::check_access::check_access_to_member_and_group;
 use crate::database::controller::groups::get_groups_for_member;
@@ -11,7 +11,7 @@ use crate::helper::translate_diesel_error::translate_diesel;
 use crate::database::controller::members::get_members_by_user_uuid;
 
 #[delete("/api/users/<user_id>", format = "json")]
-pub fn delete_user(settings: State<Settings>, cookie: SessionCookie, user_id: String) -> Result<(), Json<ApiErrorWrapper>>{
+pub fn delete_user(settings: &State<Settings>, cookie: SessionCookie, user_id: String) -> Result<(), Json<ApiErrorWrapper>>{
     let caller = parse_member_cookie(cookie.member)?;
 
     let user_id = parse_uuid_string(user_id)?;
@@ -21,15 +21,15 @@ pub fn delete_user(settings: State<Settings>, cookie: SessionCookie, user_id: St
         None => return Err(Json(ApiError::new(404, "Nicht gefunden.".to_string()).to_wrapper()))
     };
 
-    let member_groups = get_groups_for_member(&settings, member.entity_id);
+    let member_groups = get_groups_for_member(settings, member.entity_id);
 
     if caller.entity_id != member.entity_id { //Skip permission check if user edits own login
-        if !check_access_to_member_and_group(&settings, member.entity_id, member_groups, caller.entity_id, "modules.member_management.profile.login.edit".to_string()) {
+        if !check_access_to_member_and_group(settings, member.entity_id, member_groups, caller.entity_id, "modules.member_management.profile.login.edit".to_string()) {
             return Err(Json(ApiError::new(401, "Keine Rechte Login für dieses Mitglied anzulegen!".to_string()).to_wrapper()))
         }
     }
 
-    match remove_user(&settings, user_id){
+    match remove_user(settings, user_id){
         Ok(_) => Ok(()),
         Err(e) => Err(translate_diesel(e))
     }

src/modules/api/users/read.rs

@@ -1,14 +1,16 @@
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
-use rocket::{State, request, Request, Outcome, Response};
+use rocket::{State, request, Request, Response, response};
 use crate::helper::settings::Settings;
 use crate::database::controller::users::get_user_by_username;
 use crate::database::controller::login_protection::{login_attempts_exceeded, login_attempts_usernames_exceeded, add_login_attempt, add_login_attempt_username};
 use crate::database::controller::members::get_members_by_user_uuid;
-use rocket::http::hyper::header::{Authorization, Basic};
+use rocket::request::{FromRequest, Outcome};
-use rocket::request::FromRequest;
+use rocket::http::{Status, ContentType, Header};
-use rocket::http::Status;
+use std::str::{FromStr, Utf8Error};
-use std::str::FromStr;
+use rocket::http::uncased::Uncased;
-use rocket::logger::warn_;
+use std::borrow::Cow;
+use rocket::response::Responder;
+use base64::{decode, DecodeError};
 
 #[derive(Queryable, Clone, Deserialize, Serialize)]
 pub struct MatrixAuthRequest {
@@ -41,12 +43,12 @@ pub struct Auth{
 /// Matrix integration
 #[post("/_matrix-internal/identity/v1/check_credentials", format = "json", data="<auth>")]
 pub fn matrix_check_credentials(
-    settings: State<Settings>, auth: Json<MatrixAuthRequest>
+    settings: &State<Settings>, auth: Json<MatrixAuthRequest>
 ) -> Json<MatrixAuthResponse> {
     let id = auth.user.id.replace("@", "").replace(":drk.digital", "");
     match get_user_by_username(id.clone(), &settings){
         None => {
-            match login_attempts_usernames_exceeded(&settings, id.clone()){
+            match login_attempts_usernames_exceeded(settings, id.clone()){
                 Ok(result) => {
                     if result{
                         return Json(MatrixAuthResponse {
@@ -58,7 +60,7 @@ pub fn matrix_check_credentials(
                         }
                         )
                     }else{
-                        add_login_attempt_username(&settings, id);
+                        add_login_attempt_username(settings, id);
                         return Json(MatrixAuthResponse {auth: Auth{
                             success: false,
                             mxid: None,
@@ -76,7 +78,7 @@ pub fn matrix_check_credentials(
             }
         },
         Some(user) => {
-            let user = match login_attempts_usernames_exceeded(&settings, id.clone()){
+            let user = match login_attempts_usernames_exceeded(settings, id.clone()){
                 Ok(result) => {
                     if result{
                         return Json(MatrixAuthResponse {auth: Auth{
@@ -122,7 +124,7 @@ pub fn matrix_check_credentials(
                     }})
                 };
             } else {
-                add_login_attempt_username(&settings, id);
+                add_login_attempt_username(settings, id);
                 return Json(MatrixAuthResponse {auth: Auth{
                     success: false,
                     mxid: None,
@@ -135,19 +137,55 @@ pub fn matrix_check_credentials(
 
 #[derive(Debug)]
 pub struct BasicAuth{
-    auth: Basic
+    username: String,
+    password: String,
 }
 
-impl<'a, 'r> FromRequest<'a, 'r> for BasicAuth {
+fn parse_auth_header(header : &str) -> Option<BasicAuth>{
+    let mut header = &header.replace("Basic ", "");
+
+    let header = match decode(header){
+        Ok(h) => h,
+        Err(e) => {
+            warn!("Couldn't parse authorization header (base64): {}, header: {}", e, header);
+            return None
+        }
+    };
+    let header = match std::str::from_utf8(&header){
+        Ok(header) => header,
+        Err(e) => {
+            warn!("Invalid UTF-8 sequence in authorization header: {}, header: {}", e, String::from_utf8_lossy(&header));
+            return None
+        }
+    };
+    let mut parts = header.split(":");
+    let username = match parts.next(){
+        Some(username) => username.to_string(),
+        None => return None
+    };
+    let password : String = parts.collect();
+
+    if password.len() > 0 {
+        Some(BasicAuth{
+            username,
+            password
+        })
+    }else{
+        None
+    }
+}
+
+#[rocket::async_trait]
+impl<'r> FromRequest<'r> for BasicAuth{
     type Error = ();
 
-    fn from_request(request: &'a Request<'r>) -> request::Outcome<Self, Self::Error> {
+    async fn from_request(request: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
         let header: Vec<_> = request.headers().get("Authorization").collect();
 
         if header.len() == 1{
-            match Basic::from_str(&header[0].replace("Basic ", "")){
+            match parse_auth_header(&header[0]){
-                Ok(auth_parsed) => Outcome::Success(BasicAuth{auth: auth_parsed}),
+                Some(auth_parsed) => Outcome::Success(auth_parsed),
-                Err(_) => Outcome::Forward(())
+                None => Outcome::Forward(())
             }
         }else{
             Outcome::Forward(())
@@ -155,48 +193,54 @@ impl<'a, 'r> FromRequest<'a, 'r> for BasicAuth {
     }
 }
 
+pub struct HttpBasicAuth{
+    status: Status
+}
+
+impl<'r> Responder<'r, 'static> for HttpBasicAuth {
+    fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {
+        Response::build()
+            .raw_header("WWW-Authenticate", "Basic")
+            .status(self.status)
+            .ok()
+    }
+}
+
 #[get("/api/http_basic_auth", rank=2)]
-pub fn http_basic_auth2() -> rocket::Response<'static>{
+pub fn http_basic_auth2() -> HttpBasicAuth{
-    let mut response = rocket::Response::new();
+    HttpBasicAuth{
-    response.set_raw_header("WWW-Authenticate", "Basic");
+        status: Status::Unauthorized
-    response.set_status(Status::Unauthorized);
+    }
-    response
 }
 
 #[get("/api/http_basic_auth", rank=1)]
 pub fn http_basic_auth(
-    settings: State<Settings>, auth: BasicAuth
+    settings: &State<Settings>, auth: BasicAuth
-) -> rocket::Response {
+) ->  HttpBasicAuth{
-    let mut response = rocket::Response::new();
+    let mut response = HttpBasicAuth{
-    response.set_raw_header("WWW-Authenticate", "Basic");
+        status: Status::Forbidden
-    response.set_status(Status::Forbidden);
-
-    let pwd = match auth.auth.password{
-        Some(pwd) => pwd,
-        None => {
-            return response;
-        }
     };
 
-    let username = auth.auth.username;
+    let pwd = auth.password;
+    let username = auth.username;
 
     warn!("user: {}, pwd: {}", username, pwd);
 
     match get_user_by_username(username.clone(), &settings){
         None => {
-            match login_attempts_usernames_exceeded(&settings, username.clone()){
+            match login_attempts_usernames_exceeded(settings, username.clone()){
                 Ok(result) => {
                     if result{
                             return response;
                     }else{
-                        add_login_attempt_username(&settings, username.clone());
+                        add_login_attempt_username(settings, username.clone());
                     }
                 },
                 Err(_) => {}
             }
         },
         Some(user) => {
-            let user = match login_attempts_usernames_exceeded(&settings, username.clone()){
+            let user = match login_attempts_usernames_exceeded(settings, username.clone()){
                 Ok(result) => {
                     if result{
                         return response;
@@ -215,9 +259,9 @@ pub fn http_basic_auth(
                 Some(pw) => pw
             };
             if argon2::verify_encoded(&password_hash, pwd.as_ref()).unwrap() {
-                response.set_status(Status::Ok);
+                response.status = Status::Ok;
             } else {
-                add_login_attempt_username(&settings, username);
+                add_login_attempt_username(settings, username);
             }
         }
     };

src/modules/api/users/update.rs

@@ -3,7 +3,7 @@ use rocket::State;
 use crate::helper::session_cookies::model::SessionCookie;
 use crate::modules::member_management::model::login::Login;
 use crate::modules::api::model::api_outcome::{ApiErrorWrapper, ApiError};
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 use crate::modules::api::member_management::controller::parser::{parse_member_cookie, parse_uuid_string};
 use crate::helper::check_access::check_access_to_member_and_group;
 use crate::database::controller::groups::get_groups_for_member;
@@ -18,7 +18,7 @@ pub struct UpdateUserData{
 }
 
 #[put("/api/users/<user_id>", format = "json", data = "<update_user_data>")]
-pub fn update_user(settings: State<Settings>, cookie: SessionCookie, user_id: String, update_user_data: Json<UpdateUserData>) -> Result<Json<Login>, Json<ApiErrorWrapper>>{
+pub fn update_user(settings: &State<Settings>, cookie: SessionCookie, user_id: String, update_user_data: Json<UpdateUserData>) -> Result<Json<Login>, Json<ApiErrorWrapper>>{
     let caller = parse_member_cookie(cookie.member)?;
     let data = update_user_data.into_inner();
 
@@ -28,15 +28,15 @@ pub fn update_user(settings: State<Settings>, cookie: SessionCookie, user_id: St
         return Err(Json(ApiError::new(400, "User id's doesn't match".to_string()).to_wrapper()))
     }
 
-    let member_groups = get_groups_for_member(&settings, data.member_id);
+    let member_groups = get_groups_for_member(settings, data.member_id);
 
     if caller.entity_id != data.member_id { //Skip permission check if user edits own login
-        if !check_access_to_member_and_group(&settings, data.member_id, member_groups, caller.entity_id, "modules.member_management.profile.login.edit".to_string()) {
+        if !check_access_to_member_and_group(settings, data.member_id, member_groups, caller.entity_id, "modules.member_management.profile.login.edit".to_string()) {
             return Err(Json(ApiError::new(401, "Keine Rechte Login für dieses Mitglied zu verändern!".to_string()).to_wrapper()))
         }
     }
 
-    match update_user_email(&settings, user_id, data.email){
+    match update_user_email(settings, user_id, data.email){
         Ok(user) => Ok(Json(Login{
             user_id: Some(user.id),
             email: Some(user.email),

src/modules/communicator/send_email.rs

@@ -1,4 +1,4 @@
-use rocket_contrib::templates::Template;
+
 use rocket::http::Status;
 
 
@@ -6,6 +6,7 @@ use crate::helper::session_cookies::model::SessionCookie;
 use crate::helper::sitebuilder::model::general::{Header, Footer, Stylesheet, Script};
 use crate::helper::sitebuilder::model::sidebar::Sidebar;
 use crate::helper::sitebuilder::model::alerts::Alert;
+use rocket_dyn_templates::Template;
 
 #[derive(Serialize)]
 pub struct CommunicatorEmailTemplate{

src/modules/dashboard/view/mod.rs

@@ -2,12 +2,13 @@ use super::controller::render::get_context;
 use crate::helper::session_cookies::model::SessionCookie;
 use crate::helper::sitebuilder::model::alerts::{Alert, AlertClass};
 use rocket::http::Status;
-use rocket_contrib::templates::Template;
+
 use rocket::State;
 use crate::helper::settings::Settings;
+use rocket_dyn_templates::Template;
 
 #[get("/portal?<error>")]
-pub fn dashboard(settings: State<Settings>, cookie: SessionCookie, error: Option<String>) -> Result<Template, Status> {
+pub fn dashboard(settings: &State<Settings>, cookie: SessionCookie, error: Option<String>) -> Result<Template, Status> {
     let member = match cookie.member {
         //Unwraps member from cookie or send user to login if no member specified (user skipped member selection)
         Some(member) => member,
@@ -44,6 +45,6 @@ pub fn dashboard(settings: State<Settings>, cookie: SessionCookie, error: Option
 
     Ok(Template::render(
         "module_dashboard",
-        &get_context(&settings, member, alert),
+        &get_context(settings, member, alert),
     ))
 }

src/modules/event_management/add_event.rs

@@ -1,14 +1,15 @@
 use crate::helper::session_cookies::model::SessionCookie;
 use rocket::State;
 use crate::helper::settings::Settings;
-use rocket_contrib::templates::Template;
+
 use rocket::http::Status;
 use crate::helper::sitebuilder::model::general::{Header, Stylesheet, Footer, Script};
 use crate::helper::sitebuilder::model::sidebar::Sidebar;
 use crate::modules::event_management::eventlist::EventTemplates;
+use rocket_dyn_templates::Template;
 
 #[get("/portal/em/add_event")]
-pub fn add_event(cookie: SessionCookie, _settings: State<Settings>) -> Result<Template, Status> {
+pub fn add_event(cookie: SessionCookie, _settings: &State<Settings>) -> Result<Template, Status> {
     let member = match cookie.member {
         //Unwraps member from cookie or send user to login if no member specified (user skipped member selection)
         Some(member) => member,

src/modules/event_management/check_position_requirements.rs

@@ -10,7 +10,7 @@ use diesel::result::Error;
 use crate::database::controller::member_qualifications::check_qualification_for_member;
 use uuid::Uuid;
 use crate::modules::api::model::api_outcome::ApiErrorWrapper;
-use rocket_contrib::json::Json;
+use rocket::serde::json::Json;
 
 pub fn check_position_requirements(settings: &State<Settings>, position_id: uuid::Uuid, member_id: uuid::Uuid) -> Result<bool, RequirementParserError>{
     let position = match get_eu_position(settings, position_id){

src/modules/event_management/edit_event.rs

@@ -1,14 +1,15 @@
 use crate::helper::session_cookies::model::SessionCookie;
 use rocket::State;
 use crate::helper::settings::Settings;
-use rocket_contrib::templates::Template;
+
 use rocket::http::Status;
 use crate::helper::sitebuilder::model::general::{Header, Stylesheet, Footer, Script};
 use crate::helper::sitebuilder::model::sidebar::Sidebar;
 use crate::modules::event_management::eventlist::EventTemplates;
+use rocket_dyn_templates::Template;
 
 #[get("/portal/em/event?<id>")]
-pub fn edit_event(cookie: SessionCookie, _settings: State<Settings>, id: String) -> Result<Template, Status> {
+pub fn edit_event(cookie: SessionCookie, _settings: &State<Settings>, id: String) -> Result<Template, Status> {
     let member = match cookie.member {
         //Unwraps member from cookie or send user to login if no member specified (user skipped member selection)
         Some(member) => member,

src/modules/event_management/event_unit_positions.rs

@@ -1,14 +1,15 @@
 use crate::helper::session_cookies::model::SessionCookie;
 use rocket::State;
 use crate::helper::settings::Settings;
-use rocket_contrib::templates::Template;
+
 use rocket::http::Status;
 use crate::helper::sitebuilder::model::general::{Header, Stylesheet, Footer, Script};
 use crate::helper::sitebuilder::model::sidebar::Sidebar;
 use crate::modules::event_management::eventlist::EventTemplates;
+use rocket_dyn_templates::Template;
 
 #[get("/portal/em/eu_positions")]
-pub fn event_unit_positions(cookie: SessionCookie, _settings: State<Settings>) -> Result<Template, Status> {
+pub fn event_unit_positions(cookie: SessionCookie, _settings: &State<Settings>) -> Result<Template, Status> {
     let member = match cookie.member {
         //Unwraps member from cookie or send user to login if no member specified (user skipped member selection)
         Some(member) => member,

src/modules/event_management/event_unit_templates.rs

@@ -1,14 +1,15 @@
 use crate::helper::session_cookies::model::SessionCookie;
 use rocket::State;
 use crate::helper::settings::Settings;
-use rocket_contrib::templates::Template;
+
 use rocket::http::Status;
 use crate::helper::sitebuilder::model::general::{Header, Stylesheet, Footer, Script};
 use crate::helper::sitebuilder::model::sidebar::Sidebar;
 use crate::modules::event_management::eventlist::EventTemplates;
+use rocket_dyn_templates::Template;
 
 #[get("/portal/em/eu_templates")]
-pub fn event_unit_templates(cookie: SessionCookie, _settings: State<Settings>) -> Result<Template, Status> {
+pub fn event_unit_templates(cookie: SessionCookie, _settings: &State<Settings>) -> Result<Template, Status> {
     let member = match cookie.member {
         //Unwraps member from cookie or send user to login if no member specified (user skipped member selection)
         Some(member) => member,

src/modules/event_management/eventlist.rs

@@ -2,11 +2,12 @@ use crate::helper::session_cookies::model::SessionCookie;
 use crate::helper::settings::Settings;
 use rocket::http::Status;
 use rocket::State;
-use rocket_contrib::templates::Template;
+
 use crate::helper::sitebuilder::model::general::{Header, Footer, Stylesheet, Script};
 use crate::helper::sitebuilder::model::sidebar::Sidebar;
 use crate::database::model::groups::RawGroup;
 use crate::database::controller::groups::get_raw_groups;
+use rocket_dyn_templates::Template;
 
 #[derive(Serialize)]
 pub struct EventTemplates {
@@ -26,7 +27,7 @@ pub struct EventList {
 }
 
 #[get("/portal/em/list")]
-pub fn eventlist(cookie: SessionCookie, settings: State<Settings>) -> Result<Template, Status> {
+pub fn eventlist(cookie: SessionCookie, settings: &State<Settings>) -> Result<Template, Status> {
     let member = match cookie.member {
         //Unwraps member from cookie or send user to login if no member specified (user skipped member selection)
         Some(member) => member,
@@ -56,7 +57,7 @@ pub fn eventlist(cookie: SessionCookie, settings: State<Settings>) -> Result<Tem
     let mut sidebar = Sidebar::new(member.clone());
     sidebar.event_management.active = true;
 
-    let groups = match get_raw_groups(&settings){
+    let groups = match get_raw_groups(settings){
         Ok(groups) => groups,
         Err(e) => return Err(Status::InternalServerError)
     };

src/modules/event_management/organisers.rs

@@ -3,8 +3,8 @@ use crate::helper::session_cookies::model::SessionCookie;
 use crate::helper::sitebuilder::model::general::{Footer, Header, Script, Stylesheet};
 use crate::helper::sitebuilder::model::sidebar::Sidebar;
 use rocket::http::Status;
+use rocket_dyn_templates::Template;
 
-use rocket_contrib::templates::Template;
 
 #[derive(Serialize)]
 pub struct Organisers {

src/modules/member_management/controller/filter_form_from_form_trait.rs

@@ -1,33 +0,0 @@
-use crate::modules::member_management::model::filter_form::FilterForm;
-use rocket::data::FromDataSimple;
-use rocket::{Request, Data, data, Outcome};
-use rocket::outcome::Outcome::Success;
-
-/// We need to implement FromDataSimple to support multiple selected checkboxes with same name
-/// for our list filters
-impl FromDataSimple for FilterForm {
-    type Error = String;
-
-    fn from_data(req: &Request, data: Data) -> data::Outcome<Self, String> {
-        let mut selected : Vec<String> = vec![];
-
-        match req.raw_query_items(){
-            None => {Outcome::Forward(data)}
-            Some(qi) => {
-                for item in qi {
-                    if item.key.as_str() == "selected_groups" {
-                        selected.push(String::from(item.value.as_str()));
-                    }
-                }
-                if selected.len() > 0 {
-                    let form = FilterForm {
-                        selected_groups: selected
-                    };
-                    Success(form)
-                } else {
-                    Outcome::Forward(data)
-                }
-            }
-        }
-    }
-}

src/modules/member_management/controller/member_groups.rs

@@ -7,7 +7,7 @@ use crate::modules::member_management::model::groups::GroupsModule;
 use crate::modules::member_management::model::member::Member;
 use rocket::http::Status;
 use rocket::State;
-use rocket_contrib::templates::Template;
+use rocket_dyn_templates::Template;
 
 pub fn render(settings: &State<Settings>, caller: Member) -> Result<Template, Status> {
     if !caller.has_permission("modules.member_management.groups.view".to_string()) {

src/modules/member_management/controller/member_personal_profile.rs

@@ -12,9 +12,10 @@ use crate::modules::member_management::model::member::Member;
 use crate::modules::member_management::model::member_module::MemberModuleProfile;
 use rocket::http::Status;
 use rocket::State;
-use rocket_contrib::templates::Template;
+
 use crate::database::controller::units_members::get_members_units;
 use crate::database::controller::users::get_user_by_member;
+use rocket_dyn_templates::Template;
 
 pub fn handle_view(
     settings: &State<Settings>,