inject whole model manager to all controllers

src/controller/FleetController.py

@@ -1,15 +1,15 @@
 import json
 
 from flask import Flask, render_template, redirect, request, url_for, jsonify
+from src.service.ModelManager import ModelManager
 from src.model.Screen import Screen
 
 
 class FleetController:
 
-    def __init__(self, app, lang_dict, screen_manager):
+    def __init__(self, app, model_manager: ModelManager):
         self._app = app
-        self._lang_dict = lang_dict
+        self._model_manager = model_manager
-        self._screen_manager = screen_manager
         self.register()
 
     def register(self):
@@ -24,19 +24,19 @@ class FleetController:
     def fleet(self):
         return render_template(
             'fleet/fleet.jinja.html',
-            screens=self._screen_manager.get_enabled_screens(),
+            screens=self._model_manager.screen().get_enabled_screens(),
         )
 
     def fleet_screen_list(self):
         return render_template(
             'fleet/list.jinja.html',
-            l=self._lang_dict,
+            l=self._model_manager.lang().map(),
-            enabled_screens=self._screen_manager.get_enabled_screens(),
+            enabled_screens=self._model_manager.screen().get_enabled_screens(),
-            disabled_screens=self._screen_manager.get_disabled_screens(),
+            disabled_screens=self._model_manager.screen().get_disabled_screens(),
         )
 
     def fleet_screen_add(self):
-        self._screen_manager.add_form(Screen(
+        self._model_manager.screen().add_form(Screen(
             name=request.form['name'],
             host=request.form['host'],
             port=request.form['port'],
@@ -44,20 +44,20 @@ class FleetController:
         return redirect(url_for('fleet_screen_list'))
 
     def fleet_screen_edit(self):
-        self._screen_manager.update_form(request.form['id'], request.form['name'], request.form['host'], request.form['port'])
+        self._model_manager.screen().update_form(request.form['id'], request.form['name'], request.form['host'], request.form['port'])
         return redirect(url_for('fleet_screen_list'))
 
     def fleet_screen_toggle(self):
         data = request.get_json()
-        self._screen_manager.update_enabled(data.get('id'), data.get('enabled'))
+        self._model_manager.screen().update_enabled(data.get('id'), data.get('enabled'))
         return jsonify({'status': 'ok'})
 
     def fleet_screen_delete(self):
         data = request.get_json()
-        self._screen_manager.delete(data.get('id'))
+        self._model_manager.screen().delete(data.get('id'))
         return jsonify({'status': 'ok'})
 
     def fleet_screen_position(self):
         data = request.get_json()
-        self._screen_manager.update_positions(data)
+        self._model_manager.screen().update_positions(data)
         return jsonify({'status': 'ok'})

src/controller/PlayerController.py

@@ -1,19 +1,19 @@
 import json
 
 from flask import Flask, render_template, redirect, request, url_for, send_from_directory, jsonify
+from src.service.ModelManager import ModelManager
 from src.utils import get_ip_address
 
 
 class PlayerController:
 
-    def __init__(self, app, lang_dict, slide_manager):
+    def __init__(self, app, model_manager: ModelManager):
         self._app = app
-        self._lang_dict = lang_dict
+        self._model_manager = model_manager
-        self._slide_manager = slide_manager
         self.register()
 
     def _get_playlist(self) -> dict:
-        slides = self._slide_manager.to_dict(self._slide_manager.get_enabled_slides())
+        slides = self._model_manager.slide().to_dict(self._model_manager.slide().get_enabled_slides())
 
         if len(slides) == 1:
             return [slides[0], slides[0]]
@@ -35,8 +35,8 @@ class PlayerController:
         ipaddr = get_ip_address()
         return render_template(
             'player/default.jinja.html',
-            ipaddr=ipaddr if ipaddr else self._lang_dict['common_unknown_ipaddr'],
+            ipaddr=ipaddr if ipaddr else self._model_manager.lang().map().get('common_unknown_ipaddr'),
-            l=self._lang_dict
+            l=self._model_manager.lang().map()
         )
 
     def player_playlist(self):

src/controller/SettingsController.py

@@ -1,14 +1,14 @@
 import json
 
 from flask import Flask, render_template, redirect, request, url_for
+from src.service.ModelManager import ModelManager
 
 
 class SettingsController:
 
-    def __init__(self, app, lang_dict, variable_manager):
+    def __init__(self, app, model_manager: ModelManager):
         self._app = app
-        self._lang_dict = lang_dict
+        self._model_manager = model_manager
-        self._variable_manager = variable_manager
         self.register()
 
     def register(self):
@@ -18,10 +18,10 @@ class SettingsController:
     def settings_variable_list(self):
         return render_template(
             'settings/list.jinja.html',
-            l=self._lang_dict,
+            l=self._model_manager.lang().map(),
-            variables=self._variable_manager.get_editable_variables(),
+            variables=self._model_manager.variable().get_editable_variables(),
         )
 
     def settings_variable_edit(self):
-        self._variable_manager.update_form(request.form['id'], request.form['value'])
+        self._model_manager.variable().update_form(request.form['id'], request.form['value'])
         return redirect(url_for('settings_variable_list'))

src/controller/SlideshowController.py

@@ -4,6 +4,7 @@ import time
 
 from flask import Flask, render_template, redirect, request, url_for, send_from_directory, jsonify
 from werkzeug.utils import secure_filename
+from src.service.ModelManager import ModelManager
 from src.model.Slide import Slide
 from src.model.SlideType import SlideType
 from src.utils import str_to_enum
@@ -11,11 +12,9 @@ from src.utils import str_to_enum
 
 class SlideshowController:
 
-    def __init__(self, app, lang_dict, slide_manager, variable_manager):
+    def __init__(self, app, model_manager: ModelManager):
         self._app = app
-        self._lang_dict = lang_dict
+        self._model_manager = model_manager
-        self._slide_manager = slide_manager
-        self._variable_manager = variable_manager
         self.register()
 
     def register(self):
@@ -33,11 +32,11 @@ class SlideshowController:
     def slideshow(self):
         return render_template(
             'slideshow/list.jinja.html',
-            l=self._lang_dict,
+            l=self._model_manager.lang().map(),
-            enabled_slides=self._slide_manager.get_enabled_slides(),
+            enabled_slides=self._model_manager.slide().get_enabled_slides(),
-            disabled_slides=self._slide_manager.get_disabled_slides(),
+            disabled_slides=self._model_manager.slide().get_disabled_slides(),
-            var_last_restart=self._variable_manager.get_one_by_name('last_restart'),
+            var_last_restart=self._model_manager.variable().get_one_by_name('last_restart'),
-            var_external_url=self._variable_manager.get_one_by_name('external_url')
+            var_external_url=self._model_manager.variable().get_one_by_name('external_url')
         )
 
     def slideshow_slide_add(self):
@@ -64,34 +63,34 @@ class SlideshowController:
         else:
             slide.location = request.form['object']
 
-        self._slide_manager.add_form(slide)
+        self._model_manager.slide().add_form(slide)
         self._post_update()
 
         return redirect(url_for('slideshow_slide_list'))
 
     def slideshow_slide_edit(self):
-        self._slide_manager.update_form(request.form['id'], request.form['name'], request.form['duration'])
+        self._model_manager.slide().update_form(request.form['id'], request.form['name'], request.form['duration'])
         self._post_update()
         return redirect(url_for('slideshow_slide_list'))
 
     def slideshow_slide_toggle(self):
         data = request.get_json()
-        self._slide_manager.update_enabled(data.get('id'), data.get('enabled'))
+        self._model_manager.slide().update_enabled(data.get('id'), data.get('enabled'))
         self._post_update()
         return jsonify({'status': 'ok'})
 
     def slideshow_slide_delete(self):
         data = request.get_json()
-        self._slide_manager.delete(data.get('id'))
+        self._model_manager.slide().delete(data.get('id'))
         self._post_update()
         return jsonify({'status': 'ok'})
 
     def slideshow_slide_position(self):
         data = request.get_json()
-        self._slide_manager.update_positions(data)
+        self._model_manager.slide().update_positions(data)
         self._post_update()
         return jsonify({'status': 'ok'})
 
     def _post_update(self):
-        self._variable_manager.update_by_name("last_slide_update", time.time())
+        self._model_manager.variable().update_by_name("last_slide_update", time.time())
 

src/controller/SysinfoController.py

@@ -6,16 +6,16 @@ import subprocess
 from flask import Flask, render_template, jsonify
 from src.manager.VariableManager import VariableManager
 from src.manager.ConfigManager import ConfigManager
+from src.service.ModelManager import ModelManager
+
 from src.utils import get_ip_address
 
 
 class SysinfoController:
 
-    def __init__(self, app, lang_dict, config_manager: ConfigManager, variable_manager: VariableManager):
+    def __init__(self, app, model_manager: ModelManager):
         self._app = app
-        self._lang_dict = lang_dict
+        self._model_manager = model_manager
-        self._config_manager = config_manager
-        self._variable_manager = variable_manager
         self.register()
 
     def register(self):
@@ -27,14 +27,14 @@ class SysinfoController:
         ipaddr = get_ip_address()
         return render_template(
             'sysinfo/list.jinja.html',
-            ipaddr=ipaddr if ipaddr else self._lang_dict['common_unknown_ipaddr'],
+            ipaddr=ipaddr if ipaddr else self._model_manager.lang().map().get('common_unknown_ipaddr'),
-            l=self._lang_dict,
+            l=self._model_manager.lang().map(),
-            ro_variables=self._variable_manager.get_readonly_variables(),
+            ro_variables=self._model_manager.variable().get_readonly_variables(),
         )
 
     def sysinfo_restart(self):
         if platform.system().lower() == 'darwin':
-            if self._config_manager.map().get('debug'):
+            if self._model_manager.config().map().get('debug'):
                 python = sys.executable
                 os.execl(python, python, *sys.argv)
         else:
@@ -49,8 +49,8 @@ class SysinfoController:
         return jsonify({'status': 'ok'})
 
     def sysinfo_restart_needed(self):
-        var_last_slide_update = self._variable_manager.get_one_by_name('last_slide_update')
+        var_last_slide_update = self._model_manager.variable().get_one_by_name('last_slide_update')
-        var_last_restart = self._variable_manager.get_one_by_name('last_restart')
+        var_last_restart = self._model_manager.variable().get_one_by_name('last_restart')
 
         if var_last_slide_update.value <= var_last_restart.value:
             return jsonify({'status': False})

src/manager/SlideManager.py

@@ -87,7 +87,11 @@ class SlideManager:
 
         if slide:
             if slide.has_file():
-                os.unlink(slide.location)
+                try:
+                    os.unlink(slide.location)
+                except FileNotFoundError:
+                    pass
+
             self._db.delete_by_id(id)
 
     def to_dict(self, slides: List[Slide]) -> dict:

src/service/WebServer.py

@@ -58,16 +58,13 @@ class WebServer:
             self._app.config['TEMPLATES_AUTO_RELOAD'] = True
 
     def _setup_view_controllers(self) -> None:
-        lang_map = self._model_manager.lang().map()
+        PlayerController(self._app, self._model_manager)
-        mm = self._model_manager
+        SlideshowController(self._app, self._model_manager)
-
+        SettingsController(self._app, self._model_manager)
-        PlayerController(self._app, lang_map, mm.slide())
+        SysinfoController(self._app, self._model_manager)
-        SlideshowController(self._app, lang_map, mm.slide(), mm.variable())
-        SettingsController(self._app, lang_map, mm.variable())
-        SysinfoController(self._app, lang_map, mm.config(), mm.variable())
 
         if self._model_manager.variable().map().get('fleet_enabled').as_bool():
-            FleetController(self._app, lang_map, mm.screen())
+            FleetController(self._app, self._model_manager)
 
     def _setup_view_globals(self) -> None:
         @self._app.context_processor