diff --git a/src/api/endpoints/v1_api.rs b/src/api/endpoints/v1_api.rs
index a50b5d133..dfe221766 100644
--- a/src/api/endpoints/v1_api.rs
+++ b/src/api/endpoints/v1_api.rs
@@ -116,13 +116,15 @@ async fn save_config_api_proxy_config(
             return (axum::http::StatusCode::BAD_REQUEST, axum::Json(json!({"error": "Invalid content"}))).into_response();
         }
     }
+
+    // TODO wenn hot reload an ist wird doppelt geladen
     if let Some(old_api_proxy) =  app_state.config.t_api_proxy.load().clone() {
         let mut api_proxy = (*old_api_proxy).clone();
         api_proxy.server = req_api_proxy;
         let new_api_proxy = Arc::new(api_proxy);
         app_state.config.t_api_proxy.store(Some(Arc::clone(&new_api_proxy)));
         let backup_dir = app_state.config.backup_dir.as_ref().unwrap().as_str();
-        if let Some(err) = intern_save_config_api_proxy(backup_dir, &new_api_proxy, app_state.config.t_api_proxy_file_path.as_str()) {
+        if let Some(err) = intern_save_config_api_proxy(backup_dir, new_api_proxy.as_ref(), app_state.config.t_api_proxy_file_path.as_str()) {
             return (axum::http::StatusCode::INTERNAL_SERVER_ERROR, axum::Json(json!({"error": err.to_string()}))).into_response();
         }
     }
diff --git a/src/model/api_proxy.rs b/src/model/api_proxy.rs
index 759a375f8..9ad8cfcc9 100644
--- a/src/model/api_proxy.rs
+++ b/src/model/api_proxy.rs
@@ -179,7 +179,7 @@ impl FromStr for ProxyUserStatus {
             Self::TRIAL => Ok(Self::Trial),
             Self::DISABLED => Ok(Self::Disabled),
             Self::PENDING => Ok(Self::Pending),
-            _ => create_tuliprox_error_result!(TuliproxErrorKind::Info, "Unknown ProxyType: {}", s)
+            _ => create_tuliprox_error_result!(TuliproxErrorKind::Info, "Unknown ProxyUserStatus: {}", s)
         }
     }
 }
diff --git a/src/model/config.rs b/src/model/config.rs
index 8955166de..3af072e2e 100644
--- a/src/model/config.rs
+++ b/src/model/config.rs
@@ -1,25 +1,25 @@
 #![allow(clippy::struct_excessive_bools)]
+use arc_swap::ArcSwapOption;
 use enum_iterator::Sequence;
 use std::collections::{HashMap, HashSet};
 use std::fmt::Display;
 use std::path::PathBuf;
 use std::sync::Arc;
-use arc_swap::ArcSwapOption;
 
 use log::{debug, error, warn};
 use path_clean::PathClean;
 use rand::Rng;
 
-use crate::foundation::filter::{prepare_templates,  PatternTemplate};
+use crate::foundation::filter::{prepare_templates, PatternTemplate};
+use crate::model::{ApiProxyConfig, ApiProxyServerInfo, Mappings, ProxyUserCredentials};
+use crate::model::{ConfigInput, ConfigInputOptions, ConfigSource, ConfigTarget, HdHomeRunConfig, IpCheckConfig, LogConfig, MessagingConfig, ProcessTargets, ProxyConfig, TargetOutput, VideoConfig, WebUiConfig};
+use crate::tuliprox_error::create_tuliprox_error_result;
 use crate::tuliprox_error::{TuliproxError, TuliproxErrorKind};
-use crate::model::{ApiProxyConfig, ApiProxyServerInfo, ProxyUserCredentials, Mappings};
-use crate::utils::{default_as_default, default_connect_timeout_secs, default_grace_period_millis, default_grace_period_timeout_secs};
+use crate::utils::exit;
 use crate::utils::file_lock_manager::FileLockManager;
 use crate::utils::file_utils;
+use crate::utils::{default_as_default, default_connect_timeout_secs, default_grace_period_millis, default_grace_period_timeout_secs};
 use crate::utils::{parse_size_base_2, parse_to_kbps};
-use crate::utils::exit;
-use crate::tuliprox_error::{ create_tuliprox_error_result};
-use crate::model::{ConfigInput, ConfigInputOptions, IpCheckConfig, ProxyConfig, ConfigSource, ConfigTarget, HdHomeRunConfig, LogConfig, MessagingConfig, ProcessTargets, TargetOutput, VideoConfig, WebUiConfig};
 
 const STREAM_QUEUE_SIZE: usize = 1024; // mpsc channel holding messages. with 8192byte chunks and 2Mbit/s approx 8MB
 
@@ -437,7 +437,7 @@ impl Config {
                             if check_homerun {
                                 let hdhr_name = &hdhomerun_output.device;
                                 self.check_username(Some(&hdhomerun_output.username), &target.name)?;
-                                if let Some(old_hdhomerun) =  self.t_hdhomerun.load().clone() {
+                                if let Some(old_hdhomerun) = self.t_hdhomerun.load().clone() {
                                     let mut hdhomerun = (*old_hdhomerun).clone();
                                     for device in &mut hdhomerun.devices {
                                         if &device.name == hdhr_name {
@@ -688,7 +688,7 @@ impl Config {
     }
 
     fn prepare_hdhomerun(&mut self) -> Result<(), TuliproxError> {
-        if let Some(old_hdhomerun) =  &self.hdhomerun {
+        if let Some(old_hdhomerun) = &self.hdhomerun {
             let mut hdhomerun = (*old_hdhomerun).clone();
             if hdhomerun.enabled {
                 hdhomerun.prepare(self.api.port)?;
@@ -788,8 +788,14 @@ impl Config {
     /// Will panic if default server invalid
     pub fn get_server_info(&self, server_info_name: &str) -> ApiProxyServerInfo {
         let guard = self.t_api_proxy.load();
-        let server_info_list = guard.as_ref().unwrap().server.clone();
-        server_info_list.iter().find(|c| c.name.eq(server_info_name)).map_or_else(|| server_info_list.first().unwrap().clone(), Clone::clone)
+        if let Ok(api_proxy) = guard.as_ref().ok_or_else(|| {
+            TuliproxError::new(TuliproxErrorKind::Info, "API proxy config not loaded".to_string())
+        }) {
+            let server_info_list = api_proxy.server.clone();
+            server_info_list.iter().find(|c| c.name.eq(server_info_name)).map_or_else(|| server_info_list.first().unwrap().clone(), Clone::clone)
+        } else {
+            panic!("ApiProxyServer info not found");
+        }
     }
 
     pub fn get_user_server_info(&self, user: &ProxyUserCredentials) -> ApiProxyServerInfo {
diff --git a/src/model/hdhomerun_config.rs b/src/model/hdhomerun_config.rs
index f66d3988f..ad820ac49 100644
--- a/src/model/hdhomerun_config.rs
+++ b/src/model/hdhomerun_config.rs
@@ -1,7 +1,7 @@
 use std::collections::HashSet;
 use log::warn;
 use crate::tuliprox_error::{TuliproxError, TuliproxErrorKind, create_tuliprox_error_result};
-fn default_friendly_name() -> String { String::from("TuliProxTV") }
+fn default_friendly_name() -> String { String::from("TuliproxTV") }
 fn default_manufacturer() -> String { String::from("Silicondust") }
 fn default_model_name() -> String { String::from("HDTC-2US") }
 fn default_firmware_name() -> String { String::from("hdhomeruntc_atsc") }
diff --git a/src/processing/processor/playlist.rs b/src/processing/processor/playlist.rs
index 0e5d75099..81f543c51 100644
--- a/src/processing/processor/playlist.rs
+++ b/src/processing/processor/playlist.rs
@@ -156,11 +156,9 @@ fn map_channel(mut channel: PlaylistItem, mapping: &Mapping) -> PlaylistItem {
 }
 
 fn map_playlist(playlist: &mut [PlaylistGroup], target: &ConfigTarget) -> Option<Vec<PlaylistGroup>> {
-    if target.t_mapping.load().is_some() {
+    if let Some(mappings) = target.t_mapping.load().as_ref() {
         let new_playlist: Vec<PlaylistGroup> = playlist.iter().map(|playlist_group| {
             let mut grp = playlist_group.clone();
-            let guard = target.t_mapping.load();
-            let mappings = guard.as_ref().unwrap();
             mappings.iter().filter(|&mapping| !mapping.mapper.is_empty()).for_each(|mapping|
                 grp.channels = grp.channels.drain(..).map(|chan| map_channel(chan, mapping)).collect());
             grp
diff --git a/src/tuliprox_error.rs b/src/tuliprox_error.rs
index 4099ac46f..48e5ad54f 100644
--- a/src/tuliprox_error.rs
+++ b/src/tuliprox_error.rs
@@ -111,7 +111,7 @@ impl TuliproxError {
 
 impl Display for TuliproxError {
     fn fmt(&self, f: &mut Formatter) -> Result {
-        write!(f, "TuliProx error: {}", self.message)
+        write!(f, "Tuliprox error: {}", self.message)
     }
 }