Refactored code

src/cpl/logging/logger.py

@@ -0,0 +1,195 @@
+import datetime
+import os
+import traceback
+from string import Template
+
+from cpl.application.application_runtime_abc import ApplicationRuntimeABC
+from cpl.console.console import Console
+from cpl.console.foreground_color import ForegroundColor
+from cpl.logging.logger_abc import LoggerABC
+from cpl.logging.logging_level import LoggingLevel
+from cpl.logging.logging_settings import LoggingSettings
+from cpl.time.time_format_settings import TimeFormatSettings
+
+
+class Logger(LoggerABC):
+
+    def __init__(self, logging_settings: LoggingSettings, time_format: TimeFormatSettings, app_runtime: ApplicationRuntimeABC):
+        LoggerABC.__init__(self)
+
+        self._app_runtime = app_runtime
+        self._log_settings: LoggingSettings = logging_settings
+        self._time_format_settings: TimeFormatSettings = time_format
+
+        self._log = Template(self._log_settings.filename).substitute(
+            date_time_now=self._app_runtime.date_time_now.strftime(self._time_format_settings.date_time_format),
+            start_time=self._app_runtime.start_time.strftime(self._time_format_settings.date_time_log_format)
+        )
+        self._path = self._log_settings.path
+        self._level = self._log_settings.level
+        self._console = self._log_settings.console
+
+        self.create()
+
+    def _get_datetime_now(self) -> str:
+        try:
+            return datetime.datetime.now().strftime(self._time_format_settings.date_time_format)
+        except Exception as e:
+            self.error(__name__, 'Cannot get time', ex=e)
+
+    def _get_date(self) -> str:
+        try:
+            return datetime.datetime.now().strftime(self._time_format_settings.date_format)
+        except Exception as e:
+            self.error(__name__, 'Cannot get date', ex=e)
+
+    def create(self) -> None:
+        """ path """
+        try:
+            # check if log file path exists
+            if not os.path.exists(self._path):
+                os.makedirs(self._path)
+        except Exception as e:
+            self._fatal_console(__name__, 'Cannot create log dir', ex=e)
+
+        """ create new log file """
+        try:
+            # open log file, create if not exists
+            path = f'{self._path}{self._log}'
+            f = open(path, "w+")
+            Console.write_line(f'[{__name__}]: Using log file: {path}')
+            f.close()
+        except Exception as e:
+            self._fatal_console(__name__, 'Cannot open log file', ex=e)
+
+    def _append_log(self, string):
+        try:
+            # open log file and append always
+            if not os.path.isdir(self._path):
+                self._fatal_console(__name__, 'Log directory not found')
+
+            with open(self._path + self._log, "a+", encoding="utf-8") as f:
+                f.write(string + '\n')
+                f.close()
+        except Exception as e:
+            self._fatal_console(__name__, f'Cannot append log file, message: {string}', ex=e)
+
+    def _get_string(self, name: str, level: LoggingLevel, message: str) -> str:
+        log_level = level.name
+        return f'<{self._get_datetime_now()}> [ {log_level} ] [ {name} ]: {message}'
+
+    def header(self, string: str):
+        # append log and print message
+        self._append_log(string)
+        Console.set_foreground_color(ForegroundColor.default)
+        Console.write_line(string)
+        Console.set_foreground_color(ForegroundColor.default)
+
+    def trace(self, name: str, message: str):
+        output = self._get_string(name, LoggingLevel.TRACE, message)
+
+        # check if message can be written to log
+        if self._level.value >= LoggingLevel.TRACE.value:
+            self._append_log(output)
+
+        # check if message can be shown in console
+        if self._console.value >= LoggingLevel.TRACE.value:
+            Console.set_foreground_color(ForegroundColor.green)
+            Console.write_line(output)
+            Console.set_foreground_color(ForegroundColor.default)
+
+    def debug(self, name: str, message: str):
+        output = self._get_string(name, LoggingLevel.DEBUG, message)
+
+        # check if message can be written to log
+        if self._level.value >= LoggingLevel.DEBUG.value:
+            self._append_log(output)
+
+        # check if message can be shown in console
+        if self._console.value >= LoggingLevel.DEBUG.value:
+            Console.set_foreground_color(ForegroundColor.green)
+            Console.write_line(output)
+            Console.set_foreground_color(ForegroundColor.default)
+
+    def info(self, name: str, message: str):
+        output = self._get_string(name, LoggingLevel.INFO, message)
+
+        # check if message can be written to log
+        if self._level.value >= LoggingLevel.INFO.value:
+            self._append_log(output)
+
+        # check if message can be shown in console
+        if self._console.value >= LoggingLevel.INFO.value:
+            Console.set_foreground_color(ForegroundColor.green)
+            Console.write_line(output)
+            Console.set_foreground_color(ForegroundColor.default)
+
+    def warn(self, name: str, message: str):
+        output = self._get_string(name, LoggingLevel.WARN, message)
+
+        # check if message can be written to log
+        if self._level.value >= LoggingLevel.WARN.value:
+            self._append_log(output)
+
+        # check if message can be shown in console
+        if self._console.value >= LoggingLevel.WARN.value:
+            Console.set_foreground_color(ForegroundColor.yellow)
+            Console.write_line(output)
+            Console.set_foreground_color(ForegroundColor.default)
+
+    def error(self, name: str, message: str, ex: Exception = None):
+        output = ''
+        if ex is not None:
+            tb = traceback.format_exc()
+            self.error(name, message)
+            output = self._get_string(name, LoggingLevel.ERROR, f'{ex} -> {tb}')
+        else:
+            output = self._get_string(name, LoggingLevel.ERROR, message)
+
+        # check if message can be written to log
+        if self._level.value >= LoggingLevel.ERROR.value:
+            self._append_log(output)
+
+        # check if message can be shown in console
+        if self._console.value >= LoggingLevel.ERROR.value:
+            Console.set_foreground_color(ForegroundColor.red)
+            Console.write_line(output)
+            Console.set_foreground_color(ForegroundColor.default)
+
+    def fatal(self, name: str, message: str, ex: Exception = None):
+        output = ''
+        if ex is not None:
+            tb = traceback.format_exc()
+            self.error(name, message)
+            output = self._get_string(name, LoggingLevel.FATAL, f'{ex} -> {tb}')
+        else:
+            output = self._get_string(name, LoggingLevel.FATAL, message)
+
+        # check if message can be written to log
+        if self._level.value >= LoggingLevel.FATAL.value:
+            self._append_log(output)
+
+        # check if message can be shown in console
+        if self._console.value >= LoggingLevel.FATAL.value:
+            Console.set_foreground_color(ForegroundColor.red)
+            Console.write_line(output)
+            Console.set_foreground_color(ForegroundColor.default)
+
+        exit()
+
+    def _fatal_console(self, name: str, message: str, ex: Exception = None):
+        output = ''
+        if ex is not None:
+            tb = traceback.format_exc()
+            self.error(name, message)
+            output = self._get_string(name, LoggingLevel.ERROR, f'{ex} -> {tb}')
+        else:
+            output = self._get_string(name, LoggingLevel.ERROR, message)
+
+        # check if message can be shown in console
+        if self._console.value >= LoggingLevel.FATAL.value:
+            Console.set_foreground_color(ForegroundColor.red)
+            Console.write_line(output)
+            Console.set_foreground_color(ForegroundColor.default)
+
+        exit()

src/cpl/logging/logger_abc.py

@@ -0,0 +1,31 @@
+from abc import abstractmethod
+
+from cpl.dependency_injection.service_abc import ServiceABC
+
+
+class LoggerABC(ServiceABC):
+
+    @abstractmethod
+    def __init__(self):
+        ServiceABC.__init__(self)
+
+    @abstractmethod
+    def header(self, string: str): pass
+
+    @abstractmethod
+    def trace(self, name: str, message: str): pass
+
+    @abstractmethod
+    def debug(self, name: str, message: str): pass
+
+    @abstractmethod
+    def info(self, name: str, message: str): pass
+
+    @abstractmethod
+    def warn(self, name: str, message: str): pass
+
+    @abstractmethod
+    def error(self, name: str, message: str, ex: Exception = None): pass
+
+    @abstractmethod
+    def fatal(self, name: str, message: str, ex: Exception = None): pass

src/cpl/logging/logging_level.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class LoggingLevel(Enum):
+
+    OFF = 0         # Nothing
+    FATAL = 1       # Error that cause exit
+    ERROR = 2       # Non fatal error
+    WARN = 3        # Error that can later be fatal
+    INFO = 4        # Normal information's
+    DEBUG = 5       # Detailed app state
+    TRACE = 6       # Detailed app information's

src/cpl/logging/logging_settings.py

@@ -0,0 +1,62 @@
+import traceback
+from typing import Optional
+
+from cpl.configuration.configuration_model_abc import ConfigurationModelABC
+from cpl.console.console import Console
+from cpl.console.foreground_color import ForegroundColor
+from cpl.logging.logging_level import LoggingLevel
+from cpl.logging.logging_settings_name import LoggingSettingsName
+
+
+class LoggingSettings(ConfigurationModelABC):
+
+    def __init__(self):
+        ConfigurationModelABC.__init__(self)
+        self._path: Optional[str] = None
+        self._filename: Optional[str] = None
+        self._console: Optional[LoggingLevel] = None
+        self._level: Optional[LoggingLevel] = None
+
+    @property
+    def path(self) -> str:
+        return self._path
+
+    @path.setter
+    def path(self, path: str) -> None:
+        self._path = path
+
+    @property
+    def filename(self) -> str:
+        return self._filename
+
+    @filename.setter
+    def filename(self, filename: str) -> None:
+        self._filename = filename
+
+    @property
+    def console(self) -> LoggingLevel:
+        return self._console
+
+    @console.setter
+    def console(self, console: LoggingLevel) -> None:
+        self._console = console
+
+    @property
+    def level(self) -> LoggingLevel:
+        return self._level
+
+    @level.setter
+    def level(self, level: LoggingLevel) -> None:
+        self._level = level
+
+    def from_dict(self, settings: dict):
+        try:
+            self._path = settings[LoggingSettingsName.path.value]
+            self._filename = settings[LoggingSettingsName.filename.value]
+            self._console = LoggingLevel[settings[LoggingSettingsName.console_level.value]]
+            self._level = LoggingLevel[settings[LoggingSettingsName.file_level.value]]
+        except Exception as e:
+            Console.set_foreground_color(ForegroundColor.red)
+            Console.write_line(f'[ ERROR ] [ {__name__} ]: Reading error in {self.__name__} settings')
+            Console.write_line(f'[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}')
+            Console.set_foreground_color(ForegroundColor.default)

src/cpl/logging/logging_settings_name.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class LoggingSettingsName(Enum):
+
+    path = 'Path'
+    filename = 'Filename'
+    console_level = 'ConsoleLogLevel'
+    file_level = 'FileLogLevel'