Improved structure and added basics for database module

src/sh_edraft/database/__init__.py

@@ -0,0 +1,3 @@
+# imports:
+
+from .database_connection import DatabaseConnection

src/sh_edraft/database/base/__init__.py

@@ -0,0 +1,3 @@
+# imports:
+
+from .database_connection_base import DatabaseConnectionBase

src/sh_edraft/database/base/database_connection_base.py

@@ -0,0 +1,10 @@
+from abc import abstractmethod
+
+from sh_edraft.service.base.service_base import ServiceBase
+
+
+class DatabaseConnectionBase(ServiceBase):
+
+    @abstractmethod
+    def __init__(self):
+        ServiceBase.__init__(self)

src/sh_edraft/database/database_connection.py

@@ -0,0 +1,35 @@
+from typing import Optional
+
+from sqlalchemy import engine, create_engine
+from sqlalchemy.orm import session, sessionmaker
+
+from sh_edraft.database.base.database_connection_base import DatabaseConnectionBase
+from sh_edraft.database.model.database_settings import DatabaseSettings
+
+
+class DatabaseConnection(DatabaseConnectionBase):
+
+    def __init__(self, database_settings: DatabaseSettings):
+        DatabaseConnectionBase.__init__(self)
+
+        self._db_settings = database_settings
+
+        self._engine: Optional[engine] = None
+        self._session: Optional[session] = None
+        self._credentials: Optional[str] = None
+
+    def create(self):
+        self._engine = create_engine(self._db_settings.decrypted_connection_string)
+
+        if self._db_settings.encoding is not None:
+            self._engine.encoding = self._db_settings.encoding
+
+        if self._db_settings.case_sensitive is not None:
+            self._engine.case_sensitive = self._db_settings.case_sensitive
+
+        if self._db_settings.echo is not None:
+            self._engine.echo = self._db_settings.echo
+
+        db_session = sessionmaker(bind=self._engine)
+        self._session = db_session()
+

src/sh_edraft/database/model/database_settings.py

@@ -0,0 +1,80 @@
+import traceback
+from typing import Optional
+
+from sh_edraft.configuration.base.configuration_model_base import ConfigurationModelBase
+from sh_edraft.database.model.database_settings_name import DatabaseSettingsName
+from sh_edraft.utils.credential_manager import CredentialManager
+from sh_edraft.utils.console import Console
+
+
+class DatabaseSettings(ConfigurationModelBase):
+
+    def __init__(self):
+        ConfigurationModelBase.__init__(self)
+
+        self._connection_string: Optional[str] = None
+        self._credentials: Optional[str] = None
+        self._encoding: Optional[str] = None
+        self._case_sensitive: Optional[bool] = None
+        self._echo: Optional[bool] = None
+        
+    @property
+    def connection_string(self) -> str:
+        return self._connection_string
+    
+    @connection_string.setter
+    def connection_string(self, connection_string: str):
+        self._connection_string = connection_string
+        
+    @property
+    def decrypted_connection_string(self) -> str:
+        return CredentialManager.build_string(self._connection_string, self._credentials)
+        
+    @property
+    def credentials(self) -> str:
+        return self._credentials
+    
+    @credentials.setter
+    def credentials(self, credentials: str):
+        self._credentials = credentials
+
+    @property
+    def encoding(self) -> str:
+        return self._encoding
+
+    @encoding.setter
+    def encoding(self, encoding: str) -> None:
+        self._encoding = encoding
+
+    @property
+    def case_sensitive(self) -> bool:
+        return self._case_sensitive
+
+    @case_sensitive.setter
+    def case_sensitive(self, case_sensitive: bool) -> None:
+        self._case_sensitive = case_sensitive
+
+    @property
+    def echo(self) -> bool:
+        return self._echo
+
+    @echo.setter
+    def echo(self, echo: bool) -> None:
+        self._echo = echo
+
+    def from_dict(self, settings: dict):
+        try:
+            self._connection_string = settings[DatabaseSettingsName.connection_string.value]
+            self._credentials = settings[DatabaseSettingsName.credentials.value]
+
+            if DatabaseSettingsName.encoding.value in settings:
+                self._encoding = settings[DatabaseSettingsName.encoding.value]
+
+            if DatabaseSettingsName.case_sensitive.value in settings:
+                self._case_sensitive = bool(settings[DatabaseSettingsName.case_sensitive.value])
+
+            if DatabaseSettingsName.echo.value in settings:
+                self._echo = bool(settings[DatabaseSettingsName.echo.value])
+        except Exception as e:
+            Console.write_line(f'[ ERROR ] [ {__name__} ]: Reading error in {self.__name__} settings', 'red')
+            Console.write_line(f'[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}', 'red')

src/sh_edraft/database/model/database_settings_name.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class DatabaseSettingsName(Enum):
+
+    connection_string = 'ConnectionString'
+    credentials = 'Credentials'
+    encoding = 'Encoding'
+    case_sensitive = 'CaseSensitive'
+    echo = 'Echo'