.gitea/workflows/deploy_dev.yaml

@@ -24,17 +24,17 @@ jobs:
         uses: https://github.com/actions/checkout@v3
 
       - name: Shutdown stack
-        run: docker stack rm sdb_staging
+        run: docker stack rm kdb_staging
 
       - name: Prepare bot build
         run: |
-          cd bot
+          cd kdb-bot
           pip install --extra-index-url https://pip.sh-edraft.de cpl-cli
           cpl i
 
       - name: Build docker bot
         run: |
-          cd bot
+          cd kdb-bot
           docker image prune -f
           cpl docker-build
 
@@ -43,13 +43,13 @@ jobs:
 
       - name: Prepare web build
         run: |
-          cd web
+          cd kdb-web
           npm install -g ts-node
           npm i
 
       - name: Build docker web
         run: |
-          cd web
+          cd kdb-web
           docker image prune -f
           npm run docker-build
 
@@ -60,6 +60,6 @@ jobs:
           portainer-username: "gitea_job"
           portainer-password: "${{ secrets.docker_job }}"
           portainer-endpoint: 2
-          name: sdb_staging
+          name: kdb_staging
           file: ./docker-compose.staging.yml
           variables: '{}'

.gitea/workflows/deploy_prod.yaml

@@ -24,17 +24,17 @@ jobs:
         uses: https://github.com/actions/checkout@v3
 
       - name: Shutdown stack
-        run: docker stack rm sdb_prod
+        run: docker stack rm kdb_prod
 
       - name: Prepare bot build
         run: |
-          cd bot
+          cd kdb-bot
           pip install --extra-index-url https://pip.sh-edraft.de cpl-cli
           cpl i
 
       - name: Build docker bot
         run: |
-          cd bot
+          cd kdb-bot
           docker image prune -f
           cpl docker-build
 
@@ -43,13 +43,13 @@ jobs:
 
       - name: Prepare web build
         run: |
-          cd web
+          cd kdb-web
           npm install -g ts-node
           npm i
 
       - name: Build docker web
         run: |
-          cd web
+          cd kdb-web
           docker image prune -f
           npm run docker-build
 
@@ -60,6 +60,6 @@ jobs:
           portainer-username: "gitea_job"
           portainer-password: "${{ secrets.docker_job }}"
           portainer-endpoint: 2
-          name: sdb_prod
+          name: kdb_prod
           file: ./docker-compose.yml
           variables: '{}'

bot/cpl-workspace.json

@@ -32,12 +32,12 @@
       "pre-build": "cpl set-version $ARGS; black ./;",
       "post-build": "cpl run post-build --dev; black ./;",
       "pre-prod": "cpl build",
-      "prod": "export SDB_ENVIRONMENT=production; export SDB_NAME=SDB-Prod; cpl start;",
+      "prod": "export KDB_ENVIRONMENT=production; export KDB_NAME=KDB-Prod; cpl start;",
       "pre-stage": "cpl build",
-      "stage": "export SDB_ENVIRONMENT=staging; export SDB_NAME=SDB-Stage; cpl start;",
+      "stage": "export KDB_ENVIRONMENT=staging; export KDB_NAME=KDB-Stage; cpl start;",
       "pre-dev": "cpl build",
-      "dev": "export SDB_ENVIRONMENT=development; export SDB_NAME=SDB-Dev; cpl start;",
+      "dev": "export KDB_ENVIRONMENT=development; export KDB_NAME=KDB-Dev; cpl start;",
-      "docker-build": "cpl build $ARGS; docker build -t sh-edraft.de/sdb-bot:$(cpl gv) .;",
+      "docker-build": "cpl build $ARGS; docker build -t sh-edraft.de/kdb-bot:$(cpl gv) .;",
       "dc-up": "docker-compose up -d",
       "dc-down": "docker-compose down",
       "docker": "cpl dc-down; cpl docker-build; cpl dc-up;"

bot/dockerfile

@@ -2,7 +2,7 @@
 FROM python:3.10.4-alpine
 
 WORKDIR /app
-COPY ./dist/bot/build/bot/ .
+COPY ./dist/bot/build/kdb-bot/ .
 COPY ./dist/bot/build/requirements.txt .
 
 RUN python -m pip install --upgrade pip

bot/src/bot/application.py

@@ -23,17 +23,25 @@ class Application(DiscordBotApplicationABC):
 
         # cpl-core
         self._logger: LoggerABC = services.get_service(LoggerABC)
-        self._data_integrity: DataIntegrityService = services.get_service(DataIntegrityService)
+        self._data_integrity: DataIntegrityService = services.get_service(
+            DataIntegrityService
+        )
         # cpl-discord
         self._bot: DiscordBotServiceABC = services.get_service(DiscordBotServiceABC)
-        self._bot_settings: DiscordBotSettings = config.get_configuration(DiscordBotSettings)
+        self._bot_settings: DiscordBotSettings = config.get_configuration(
+            DiscordBotSettings
+        )
         # cpl-translation
-        self._translation: TranslationServiceABC = services.get_service(TranslationServiceABC)
+        self._translation: TranslationServiceABC = services.get_service(
+            TranslationServiceABC
+        )
         self._t: TranslatePipe = services.get_service(TranslatePipe)
         # internal stuff
         self._tasks = services.get_services(TaskABC)
 
-        self._feature_flags: FeatureFlagsSettings = config.get_configuration(FeatureFlagsSettings)
+        self._feature_flags: FeatureFlagsSettings = config.get_configuration(
+            FeatureFlagsSettings
+        )
 
         # api
         if self._feature_flags.get_flag(FeatureFlagsEnum.api_module):
@@ -42,7 +50,9 @@ class Application(DiscordBotApplicationABC):
         self._is_stopping = False
 
     async def configure(self):
-        self._translation.load_by_settings(self._configuration.get_configuration(TranslationSettings))
+        self._translation.load_by_settings(
+            self._configuration.get_configuration(TranslationSettings)
+        )
 
     async def main(self):
         try:
@@ -85,4 +95,8 @@ class Application(DiscordBotApplicationABC):
         Console.write_line()
 
     def is_restart(self):
-        return True if self._configuration.get_configuration("IS_RESTART") == "true" else False
+        return (
+            True
+            if self._configuration.get_configuration("IS_RESTART") == "true"
+            else False
+        )

bot/src/bot/extension/init_bot_extension.py

@@ -13,4 +13,6 @@ class InitBotExtension(ApplicationExtensionABC):
     async def run(self, config: ConfigurationABC, services: ServiceProviderABC):
         settings = config.get_configuration(TechnicianConfig)
 
-        bot: DiscordBotServiceABC = services.get_service(DiscordBotServiceABC, max_messages=settings.cache_max_messages)
+        bot: DiscordBotServiceABC = services.get_service(
+            DiscordBotServiceABC, max_messages=settings.cache_max_messages
+        )

bot/src/bot/startup.py

@@ -50,7 +50,9 @@ class Startup(StartupABC):
             services.add_singleton(CustomFileLoggerABC, ApiLogger)
 
         services.add_translation()
-        services.add_db_context(DBContext, self._config.get_configuration(DatabaseSettings))
+        services.add_db_context(
+            DBContext, self._config.get_configuration(DatabaseSettings)
+        )
 
         provider = services.build_service_provider()
         # instantiate custom logger

bot/src/bot/startup_discord_extension.py

@@ -9,9 +9,13 @@ class StartupDiscordExtension(StartupExtensionABC):
     def __init__(self):
         pass
 
-    def configure_configuration(self, config: ConfigurationABC, env: ApplicationEnvironmentABC):
+    def configure_configuration(
+        self, config: ConfigurationABC, env: ApplicationEnvironmentABC
+    ):
         pass
 
-    def configure_services(self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC):
+    def configure_services(
+        self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC
+    ):
         services.add_discord()
         dcc = get_discord_collection(services)

bot/src/bot/startup_migration_extension.py

@@ -41,30 +41,66 @@ class StartupMigrationExtension(StartupExtensionABC):
     def __init__(self):
         pass
 
-    def configure_configuration(self, config: ConfigurationABC, env: ApplicationEnvironmentABC):
+    def configure_configuration(
+        self, config: ConfigurationABC, env: ApplicationEnvironmentABC
+    ):
         pass
 
-    def configure_services(self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC):
+    def configure_services(
+        self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC
+    ):
         services.add_transient(MigrationService)
         services.add_transient(MigrationABC, InitialMigration)
-        services.add_transient(MigrationABC, AutoRoleMigration)  # 03.10.2022 #54 - 0.2.2
+        services.add_transient(
+            MigrationABC, AutoRoleMigration
+        )  # 03.10.2022 #54 - 0.2.2
         services.add_transient(MigrationABC, ApiMigration)  # 15.10.2022 #70 - 0.3.0
         services.add_transient(MigrationABC, LevelMigration)  # 06.11.2022 #25 - 0.3.0
         services.add_transient(MigrationABC, StatsMigration)  # 09.11.2022 #46 - 0.3.0
-        services.add_transient(MigrationABC, AutoRoleFix1Migration)  # 30.12.2022 #151 - 0.3.0
+        services.add_transient(
-        services.add_transient(MigrationABC, UserMessageCountPerHourMigration)  # 11.01.2023 #168 - 0.3.1
+            MigrationABC, AutoRoleFix1Migration
+        )  # 30.12.2022 #151 - 0.3.0
+        services.add_transient(
+            MigrationABC, UserMessageCountPerHourMigration
+        )  # 11.01.2023 #168 - 0.3.1
         services.add_transient(MigrationABC, ApiKeyMigration)  # 09.02.2023 #162 - 1.0.0
-        services.add_transient(MigrationABC, UserJoinedGameServerMigration)  # 12.02.2023 #181 - 1.0.0
+        services.add_transient(
-        services.add_transient(MigrationABC, RemoveStatsMigration)  # 19.02.2023 #190 - 1.0.0
+            MigrationABC, UserJoinedGameServerMigration
-        services.add_transient(MigrationABC, UserWarningMigration)  # 21.02.2023 #35 - 1.0.0
+        )  # 12.02.2023 #181 - 1.0.0
-        services.add_transient(MigrationABC, DBHistoryMigration)  # 06.03.2023 #246 - 1.0.0
+        services.add_transient(
-        services.add_transient(MigrationABC, AchievementsMigration)  # 14.06.2023 #268 - 1.1.0
+            MigrationABC, RemoveStatsMigration
+        )  # 19.02.2023 #190 - 1.0.0
+        services.add_transient(
+            MigrationABC, UserWarningMigration
+        )  # 21.02.2023 #35 - 1.0.0
+        services.add_transient(
+            MigrationABC, DBHistoryMigration
+        )  # 06.03.2023 #246 - 1.0.0
+        services.add_transient(
+            MigrationABC, AchievementsMigration
+        )  # 14.06.2023 #268 - 1.1.0
         services.add_transient(MigrationABC, ConfigMigration)  # 19.07.2023 #127 - 1.1.0
-        services.add_transient(MigrationABC, ConfigFeatureFlagsMigration)  # 15.08.2023 #334 - 1.1.0
+        services.add_transient(
-        services.add_transient(MigrationABC, DefaultRoleMigration)  # 24.09.2023 #360 - 1.1.3
+            MigrationABC, ConfigFeatureFlagsMigration
-        services.add_transient(MigrationABC, ShortRoleNameMigration)  # 28.09.2023 #378 - 1.1.7
+        )  # 15.08.2023 #334 - 1.1.0
-        services.add_transient(MigrationABC, FixUpdatesMigration)  # 28.09.2023 #378 - 1.1.7
+        services.add_transient(
-        services.add_transient(MigrationABC, ShortRoleNameOnlyHighestMigration)  # 02.10.2023 #391 - 1.1.9
+            MigrationABC, DefaultRoleMigration
-        services.add_transient(MigrationABC, FixUserHistoryMigration)  # 10.10.2023 #401 - 1.2.0
+        )  # 24.09.2023 #360 - 1.1.3
-        services.add_transient(MigrationABC, BirthdayMigration)  # 10.10.2023 #401 - 1.2.0
+        services.add_transient(
-        services.add_transient(MigrationABC, SteamSpecialOfferMigration)  # 10.10.2023 #188 - 1.2.0
+            MigrationABC, ShortRoleNameMigration
+        )  # 28.09.2023 #378 - 1.1.7
+        services.add_transient(
+            MigrationABC, FixUpdatesMigration
+        )  # 28.09.2023 #378 - 1.1.7
+        services.add_transient(
+            MigrationABC, ShortRoleNameOnlyHighestMigration
+        )  # 02.10.2023 #391 - 1.1.9
+        services.add_transient(
+            MigrationABC, FixUserHistoryMigration
+        )  # 10.10.2023 #401 - 1.2.0
+        services.add_transient(
+            MigrationABC, BirthdayMigration
+        )  # 10.10.2023 #401 - 1.2.0
+        services.add_transient(
+            MigrationABC, SteamSpecialOfferMigration
+        )  # 10.10.2023 #188 - 1.2.0

bot/src/bot/startup_module_extension.py

@@ -18,11 +18,15 @@ class StartupModuleExtension(StartupExtensionABC):
 
         self._modules = ModuleList.get_modules()
 
-    def configure_configuration(self, config: ConfigurationABC, env: ApplicationEnvironmentABC):
+    def configure_configuration(
+        self, config: ConfigurationABC, env: ApplicationEnvironmentABC
+    ):
         self._config = config
         self._feature_flags = config.get_configuration(FeatureFlagsSettings)
 
-    def configure_services(self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC):
+    def configure_services(
+        self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC
+    ):
         provider = services.build_service_provider()
         dc_collection: DiscordCollectionABC = provider.get_service(DiscordCollectionABC)
 

bot/src/bot/startup_settings_extension.py

@@ -14,26 +14,38 @@ class StartupSettingsExtension(StartupExtensionABC):
     def __init__(self):
         self._start_time = datetime.now()
 
-    def configure_configuration(self, configuration: ConfigurationABC, environment: ApplicationEnvironmentABC):
+    def configure_configuration(
+        self, configuration: ConfigurationABC, environment: ApplicationEnvironmentABC
+    ):
         # this shit has to be done here because we need settings in subsequent startup extensions
         environment.set_working_directory(os.path.dirname(os.path.realpath(__file__)))
         configuration.add_environment_variables("KDB_")
         configuration.add_environment_variables("DISCORD_")
 
         configuration.add_json_file(f"config/appsettings.json", optional=False)
-        configuration.add_json_file(f"config/appsettings.{environment.environment_name}.json", optional=True)
+        configuration.add_json_file(
-        configuration.add_json_file(f"config/appsettings.{environment.host_name}.json", optional=True)
+            f"config/appsettings.{environment.environment_name}.json", optional=True
+        )
+        configuration.add_json_file(
+            f"config/appsettings.{environment.host_name}.json", optional=True
+        )
         # load feature-flags
         configuration.add_json_file(f"config/feature-flags.json", optional=False)
-        configuration.add_json_file(f"config/feature-flags.{environment.environment_name}.json", optional=True)
+        configuration.add_json_file(
-        configuration.add_json_file(f"config/feature-flags.{environment.host_name}.json", optional=True)
+            f"config/feature-flags.{environment.environment_name}.json", optional=True
+        )
+        configuration.add_json_file(
+            f"config/feature-flags.{environment.host_name}.json", optional=True
+        )
 
         configuration.add_configuration("Startup_StartTime", str(self._start_time))
         self._configure_settings_with_sub_settings(
             configuration, BotLoggingSettings, lambda x: x.files, lambda x: x.key
         )
 
-    def configure_services(self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC):
+    def configure_services(
+        self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC
+    ):
         pass
 
     @staticmethod
@@ -45,4 +57,6 @@ class StartupSettingsExtension(StartupExtensionABC):
             return
 
         for sub_settings in list_atr(settings):
-            config.add_configuration(f"{type(sub_settings).__name__}_{atr(sub_settings)}", sub_settings)
+            config.add_configuration(
+                f"{type(sub_settings).__name__}_{atr(sub_settings)}", sub_settings
+            )

bot/src/bot_api/abc/auth_service_abc.py

@@ -40,11 +40,15 @@ class AuthServiceABC(ABC):
         pass
 
     @abstractmethod
-    async def get_filtered_auth_users_async(self, criteria: AuthUserSelectCriteria) -> AuthUserFilteredResultDTO:
+    async def get_filtered_auth_users_async(
+        self, criteria: AuthUserSelectCriteria
+    ) -> AuthUserFilteredResultDTO:
         pass
 
     @abstractmethod
-    async def get_auth_user_by_email_async(self, email: str, with_password: bool = False) -> AuthUserDTO:
+    async def get_auth_user_by_email_async(
+        self, email: str, with_password: bool = False
+    ) -> AuthUserDTO:
         pass
 
     @abstractmethod

bot/src/bot_api/abc/select_criteria_abc.py

@@ -3,7 +3,9 @@ from abc import ABC, abstractmethod
 
 class SelectCriteriaABC(ABC):
     @abstractmethod
-    def __init__(self, page_index: int, page_size: int, sort_direction: str, sort_column: str):
+    def __init__(
+        self, page_index: int, page_size: int, sort_direction: str, sort_column: str
+    ):
         self.page_index = page_index
         self.page_size = page_size
         self.sort_direction = sort_direction

bot/src/bot_api/api.py

@@ -57,7 +57,9 @@ class Api(Flask):
         # Added async_mode see link below
         # https://github.com/miguelgrinberg/Flask-SocketIO/discussions/1849
         # https://stackoverflow.com/questions/39370848/flask-socket-io-sometimes-client-calls-freeze-the-server
-        self._socketio = SocketIO(self, cors_allowed_origins="*", path="/api/socket.io", async_mode="eventlet")
+        self._socketio = SocketIO(
+            self, cors_allowed_origins="*", path="/api/socket.io", async_mode="eventlet"
+        )
         self._socketio.on_event("connect", self.on_connect)
         self._socketio.on_event("disconnect", self.on_disconnect)
 
@@ -143,7 +145,9 @@ class Api(Flask):
         data = request.get_data()
         data = "" if len(data) == 0 else str(data.decode(encoding="utf-8"))
 
-        text = textwrap.dedent(f"Request: {request_id}:\n\tHeader:\n\t\t{headers}\n\tResponse: {data}")
+        text = textwrap.dedent(
+            f"Request: {request_id}:\n\tHeader:\n\t\t{headers}\n\tResponse: {data}"
+        )
         self._logger.trace(__name__, text)
 
         return response
@@ -158,7 +162,9 @@ class Api(Flask):
         # from waitress import serve
         # https://docs.pylonsproject.org/projects/waitress/en/stable/arguments.html
         # serve(self, host=self._apt_settings.host, port=self._apt_settings.port, threads=10, connection_limit=1000, channel_timeout=10)
-        self._socket = eventlet.listen((self._api_settings.host, self._api_settings.port))
+        self._socket = eventlet.listen(
+            (self._api_settings.host, self._api_settings.port)
+        )
         wsgi.server(self._socket, self, log_output=False)
 
     def stop(self):

bot/src/bot_api/api_module.py

@@ -26,15 +26,21 @@ class ApiModule(ModuleABC):
     def __init__(self, dc: DiscordCollectionABC):
         ModuleABC.__init__(self, dc, FeatureFlagsEnum.api_module)
 
-    def configure_configuration(self, config: ConfigurationABC, env: ApplicationEnvironmentABC):
+    def configure_configuration(
+        self, config: ConfigurationABC, env: ApplicationEnvironmentABC
+    ):
         cwd = env.working_directory
         env.set_working_directory(os.path.dirname(os.path.realpath(__file__)))
         config.add_json_file(f"config/apisettings.json", optional=False)
-        config.add_json_file(f"config/apisettings.{env.environment_name}.json", optional=True)
+        config.add_json_file(
+            f"config/apisettings.{env.environment_name}.json", optional=True
+        )
         config.add_json_file(f"config/apisettings.{env.host_name}.json", optional=True)
         env.set_working_directory(cwd)
 
-    def configure_services(self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC):
+    def configure_services(
+        self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC
+    ):
         services.add_singleton(EMailClientABC, EMailClient)
 
         services.add_singleton(ApiThread)

bot/src/bot_api/app_api_extension.py

@@ -12,7 +12,9 @@ class AppApiExtension(ApplicationExtensionABC):
         ApplicationExtensionABC.__init__(self)
 
     async def run(self, config: ConfigurationABC, services: ServiceProviderABC):
-        feature_flags: FeatureFlagsSettings = config.get_configuration(FeatureFlagsSettings)
+        feature_flags: FeatureFlagsSettings = config.get_configuration(
+            FeatureFlagsSettings
+        )
         if not feature_flags.get_flag(FeatureFlagsEnum.api_module):
             return
 

bot/src/bot_api/configuration/authentication_settings.py

@@ -16,7 +16,9 @@ class AuthenticationSettings(ConfigurationModelABC):
         self._issuer = "" if issuer is None else issuer
         self._audience = "" if audience is None else audience
         self._token_expire_time = 0 if token_expire_time is None else token_expire_time
-        self._refresh_token_expire_time = 0 if refresh_token_expire_time is None else refresh_token_expire_time
+        self._refresh_token_expire_time = (
+            0 if refresh_token_expire_time is None else refresh_token_expire_time
+        )
 
     @property
     def secret_key(self) -> str:

bot/src/bot_api/controller/auth_controller.py

@@ -70,7 +70,9 @@ class AuthController:
 
     @Route.post(f"{BasePath}/register")
     async def register(self):
-        dto: AuthUserDTO = JSONProcessor.process(AuthUserDTO, request.get_json(force=True, silent=True))
+        dto: AuthUserDTO = JSONProcessor.process(
+            AuthUserDTO, request.get_json(force=True, silent=True)
+        )
         self._auth_service.add_auth_user(dto)
         return "", 200
 
@@ -81,7 +83,9 @@ class AuthController:
 
     @Route.post(f"{BasePath}/login")
     async def login(self) -> Response:
-        dto: AuthUserDTO = JSONProcessor.process(AuthUserDTO, request.get_json(force=True, silent=True))
+        dto: AuthUserDTO = JSONProcessor.process(
+            AuthUserDTO, request.get_json(force=True, silent=True)
+        )
         result = await self._auth_service.login_async(dto)
         return jsonify(result.to_dict())
 
@@ -110,40 +114,52 @@ class AuthController:
 
     @Route.post(f"{BasePath}/reset-password")
     async def reset_password(self):
-        dto: ResetPasswordDTO = JSONProcessor.process(ResetPasswordDTO, request.get_json(force=True, silent=True))
+        dto: ResetPasswordDTO = JSONProcessor.process(
+            ResetPasswordDTO, request.get_json(force=True, silent=True)
+        )
         await self._auth_service.reset_password_async(dto)
         return "", 200
 
     @Route.post(f"{BasePath}/update-user")
     @Route.authorize
     async def update_user(self):
-        dto: UpdateAuthUserDTO = JSONProcessor.process(UpdateAuthUserDTO, request.get_json(force=True, silent=True))
+        dto: UpdateAuthUserDTO = JSONProcessor.process(
+            UpdateAuthUserDTO, request.get_json(force=True, silent=True)
+        )
         await self._auth_service.update_user_async(dto)
         return "", 200
 
     @Route.post(f"{BasePath}/update-user-as-admin")
     @Route.authorize(role=AuthRoleEnum.admin)
     async def update_user_as_admin(self):
-        dto: UpdateAuthUserDTO = JSONProcessor.process(UpdateAuthUserDTO, request.get_json(force=True, silent=True))
+        dto: UpdateAuthUserDTO = JSONProcessor.process(
+            UpdateAuthUserDTO, request.get_json(force=True, silent=True)
+        )
         await self._auth_service.update_user_as_admin_async(dto)
         return "", 200
 
     @Route.post(f"{BasePath}/refresh")
     async def refresh(self) -> Response:
-        dto: TokenDTO = JSONProcessor.process(TokenDTO, request.get_json(force=True, silent=True))
+        dto: TokenDTO = JSONProcessor.process(
+            TokenDTO, request.get_json(force=True, silent=True)
+        )
         result = await self._auth_service.refresh_async(dto)
         return jsonify(result.to_dict())
 
     @Route.post(f"{BasePath}/revoke")
     async def revoke(self):
-        dto: TokenDTO = JSONProcessor.process(TokenDTO, request.get_json(force=True, silent=True))
+        dto: TokenDTO = JSONProcessor.process(
+            TokenDTO, request.get_json(force=True, silent=True)
+        )
         await self._auth_service.revoke_async(dto)
         return "", 200
 
     @Route.post(f"{BasePath}/delete-user")
     @Route.authorize(role=AuthRoleEnum.admin)
     async def delete_user(self):
-        dto: AuthUserDTO = JSONProcessor.process(AuthUserDTO, request.get_json(force=True, silent=True))
+        dto: AuthUserDTO = JSONProcessor.process(
+            AuthUserDTO, request.get_json(force=True, silent=True)
+        )
         await self._auth_service.delete_auth_user_async(dto)
         return "", 200
 

bot/src/bot_api/filter/auth_user_select_criteria.py

@@ -13,7 +13,9 @@ class AuthUserSelectCriteria(SelectCriteriaABC):
         email: str,
         auth_role: int,
     ):
-        SelectCriteriaABC.__init__(self, page_index, page_size, sort_direction, sort_column)
+        SelectCriteriaABC.__init__(
+            self, page_index, page_size, sort_direction, sort_column
+        )
 
         self.first_name = first_name
         self.last_name = last_name

bot/src/bot_api/filter/discord/server_select_criteria.py

@@ -10,6 +10,8 @@ class ServerSelectCriteria(SelectCriteriaABC):
         sort_column: str,
         name: str,
     ):
-        SelectCriteriaABC.__init__(self, page_index, page_size, sort_direction, sort_column)
+        SelectCriteriaABC.__init__(
+            self, page_index, page_size, sort_direction, sort_column
+        )
 
         self.name = name

bot/src/bot_api/model/error_dto.py

@@ -11,7 +11,9 @@ class ErrorDTO(DtoABC):
     def __init__(self, error_code: Optional[ServiceErrorCode], message: str):
         DtoABC.__init__(self)
 
-        self._error_code = ServiceErrorCode.Unknown if error_code is None else error_code
+        self._error_code = (
+            ServiceErrorCode.Unknown if error_code is None else error_code
+        )
         self._message = message
 
     @property

bot/src/bot_api/model/update_auth_user_dto.py

@@ -34,7 +34,9 @@ class UpdateAuthUserDTO(DtoABC):
     def from_dict(self, values: dict):
         self._auth_user = AuthUserDTO().from_dict(values["authUser"])
         self._new_auth_user = AuthUserDTO().from_dict(values["newAuthUser"])
-        self._change_password = False if "changePassword" not in values else bool(values["changePassword"])
+        self._change_password = (
+            False if "changePassword" not in values else bool(values["changePassword"])
+        )
 
     def to_dict(self) -> dict:
         return {

bot/src/bot_api/route/route.py

@@ -65,7 +65,9 @@ class Route:
         by_api_key=False,
     ):
         if f is None:
-            return functools.partial(cls.authorize, role=role, skip_in_dev=skip_in_dev, by_api_key=by_api_key)
+            return functools.partial(
+                cls.authorize, role=role, skip_in_dev=skip_in_dev, by_api_key=by_api_key
+            )
 
         @wraps(f)
         async def decorator(*args, **kwargs):
@@ -76,7 +78,9 @@ class Route:
             api_key = None
             if "Authorization" in request.headers:
                 if " " not in request.headers.get("Authorization"):
-                    ex = ServiceException(ServiceErrorCode.Unauthorized, f"Token not set")
+                    ex = ServiceException(
+                        ServiceErrorCode.Unauthorized, f"Token not set"
+                    )
                     error = ErrorDTO(ex.error_code, ex.message)
                     return jsonify(error.to_dict()), 401
 
@@ -98,7 +102,9 @@ class Route:
                     return jsonify(e), 500
 
                 if not valid:
-                    ex = ServiceException(ServiceErrorCode.Unauthorized, f"API-Key invalid")
+                    ex = ServiceException(
+                        ServiceErrorCode.Unauthorized, f"API-Key invalid"
+                    )
                     error = ErrorDTO(ex.error_code, ex.message)
                     return jsonify(error.to_dict()), 401
 
@@ -110,7 +116,9 @@ class Route:
                 return jsonify(error.to_dict()), 401
 
             if cls._auth_users is None or cls._auth is None:
-                ex = ServiceException(ServiceErrorCode.Unauthorized, f"Authorize is not initialized")
+                ex = ServiceException(
+                    ServiceErrorCode.Unauthorized, f"Authorize is not initialized"
+                )
                 error = ErrorDTO(ex.error_code, ex.message)
                 return jsonify(error.to_dict()), 401
 
@@ -132,7 +140,9 @@ class Route:
                 return jsonify(error.to_dict()), 401
 
             if role is not None and user.auth_role.value < role.value:
-                ex = ServiceException(ServiceErrorCode.Unauthorized, f"Role {role} required")
+                ex = ServiceException(
+                    ServiceErrorCode.Unauthorized, f"Role {role} required"
+                )
                 error = ErrorDTO(ex.error_code, ex.message)
                 return jsonify(error.to_dict()), 403
 

bot/src/bot_api/service/auth_service.py

@@ -90,7 +90,9 @@ class AuthService(AuthServiceABC):
 
     def _get_api_key_str(self, api_key: ApiKey) -> str:
         return hashlib.sha256(
-            f"{api_key.identifier}:{api_key.key}+{self._auth_settings.secret_key}".encode("utf-8")
+            f"{api_key.identifier}:{api_key.key}+{self._auth_settings.secret_key}".encode(
+                "utf-8"
+            )
         ).hexdigest()
 
     def generate_token(self, user: AuthUser) -> str:
@@ -99,7 +101,8 @@ class AuthService(AuthServiceABC):
                 "user_id": user.id,
                 "email": user.email,
                 "role": user.auth_role.value,
-                "exp": datetime.now(tz=timezone.utc) + timedelta(days=self._auth_settings.token_expire_time),
+                "exp": datetime.now(tz=timezone.utc)
+                + timedelta(days=self._auth_settings.token_expire_time),
                 "iss": self._auth_settings.issuer,
                 "aud": self._auth_settings.audience,
             },
@@ -155,7 +158,9 @@ class AuthService(AuthServiceABC):
     def _create_and_save_refresh_token(self, user: AuthUser) -> str:
         token = str(uuid.uuid4())
         user.refresh_token = token
-        user.refresh_token_expire_time = datetime.now() + timedelta(days=self._auth_settings.refresh_token_expire_time)
+        user.refresh_token_expire_time = datetime.now() + timedelta(
+            days=self._auth_settings.refresh_token_expire_time
+        )
         self._auth_users.update_auth_user(user)
         self._db.save_changes()
         return token
@@ -188,8 +193,12 @@ class AuthService(AuthServiceABC):
 
         self._send_link_mail(
             user.email,
-            self._t.transform("api.auth.confirmation.subject").format(user.first_name, user.last_name),
+            self._t.transform("api.auth.confirmation.subject").format(
-            self._t.transform("api.auth.confirmation.message").format(url, user.confirmation_id),
+                user.first_name, user.last_name
+            ),
+            self._t.transform("api.auth.confirmation.message").format(
+                url, user.confirmation_id
+            ),
         )
 
     def _send_forgot_password_id_to_user(self, user: AuthUser):
@@ -199,28 +208,38 @@ class AuthService(AuthServiceABC):
 
         self._send_link_mail(
             user.email,
-            self._t.transform("api.auth.forgot_password.subject").format(user.first_name, user.last_name),
+            self._t.transform("api.auth.forgot_password.subject").format(
-            self._t.transform("api.auth.forgot_password.message").format(url, user.forgot_password_id),
+                user.first_name, user.last_name
+            ),
+            self._t.transform("api.auth.forgot_password.message").format(
+                url, user.forgot_password_id
+            ),
         )
 
     async def get_all_auth_users_async(self) -> List[AuthUserDTO]:
         result = self._auth_users.get_all_auth_users().select(lambda x: AUT.to_dto(x))
         return List(AuthUserDTO, result)
 
-    async def get_filtered_auth_users_async(self, criteria: AuthUserSelectCriteria) -> AuthUserFilteredResultDTO:
+    async def get_filtered_auth_users_async(
+        self, criteria: AuthUserSelectCriteria
+    ) -> AuthUserFilteredResultDTO:
         users = self._auth_users.get_filtered_auth_users(criteria)
         result = users.result.select(lambda x: AUT.to_dto(x))
 
         return AuthUserFilteredResultDTO(List(AuthUserDTO, result), users.total_count)
 
-    async def get_auth_user_by_email_async(self, email: str, with_password: bool = False) -> AuthUserDTO:
+    async def get_auth_user_by_email_async(
+        self, email: str, with_password: bool = False
+    ) -> AuthUserDTO:
         try:
             # todo: check if logged in user is admin then send mail
             user = self._auth_users.get_auth_user_by_email(email)
             return AUT.to_dto(user, password=user.password if with_password else None)
         except Exception as e:
             self._logger.error(__name__, f"AuthUser not found", e)
-            raise ServiceException(ServiceErrorCode.InvalidData, f"User not found {email}")
+            raise ServiceException(
+                ServiceErrorCode.InvalidData, f"User not found {email}"
+            )
 
     async def find_auth_user_by_email_async(self, email: str) -> Optional[AuthUser]:
         user = self._auth_users.find_auth_user_by_email(email)
@@ -238,16 +257,22 @@ class AuthService(AuthServiceABC):
         user.password_salt = uuid.uuid4()
         user.password = self._hash_sha256(user_dto.password, user.password_salt)
         if not self._is_email_valid(user.email):
-            raise ServiceException(ServiceErrorCode.InvalidData, "Invalid E-Mail address")
+            raise ServiceException(
+                ServiceErrorCode.InvalidData, "Invalid E-Mail address"
+            )
 
         try:
             user.confirmation_id = uuid.uuid4()
             self._auth_users.add_auth_user(user)
             self._send_confirmation_id_to_user(user)
             self._db.save_changes()
-            self._logger.info(__name__, f"Added auth user with E-Mail: {user_dto.email}")
+            self._logger.info(
+                __name__, f"Added auth user with E-Mail: {user_dto.email}"
+            )
         except Exception as e:
-            self._logger.error(__name__, f"Cannot add user with E-Mail {user_dto.email}", e)
+            self._logger.error(
+                __name__, f"Cannot add user with E-Mail {user_dto.email}", e
+            )
             raise ServiceException(ServiceErrorCode.UnableToAdd, "Invalid E-Mail")
 
     async def add_auth_user_by_oauth_async(self, dto: OAuthDTO):
@@ -263,14 +288,20 @@ class AuthService(AuthServiceABC):
             db_user.first_name = dto.user.first_name
             db_user.last_name = dto.user.last_name
             db_user.password_salt = uuid.uuid4()
-            db_user.password = self._hash_sha256(dto.user.password, db_user.password_salt)
+            db_user.password = self._hash_sha256(
+                dto.user.password, db_user.password_salt
+            )
             db_user.oauth_id = None
             db_user.confirmation_id = uuid.uuid4()
             self._send_confirmation_id_to_user(db_user)
             self._auth_users.update_auth_user(db_user)
-            self._logger.info(__name__, f"Added auth user with E-Mail: {dto.user.email}")
+            self._logger.info(
+                __name__, f"Added auth user with E-Mail: {dto.user.email}"
+            )
         except Exception as e:
-            self._logger.error(__name__, f"Cannot add user with E-Mail {dto.user.email}", e)
+            self._logger.error(
+                __name__, f"Cannot add user with E-Mail {dto.user.email}", e
+            )
             raise ServiceException(ServiceErrorCode.UnableToAdd, "Invalid E-Mail")
 
         self._db.save_changes()
@@ -280,14 +311,16 @@ class AuthService(AuthServiceABC):
             raise ServiceException(ServiceErrorCode.InvalidData, f"User is empty")
 
         if update_user_dto.auth_user is None:
-            raise ServiceException(ServiceErrorCode.InvalidData, f"Existing user is empty")
+            raise ServiceException(
+                ServiceErrorCode.InvalidData, f"Existing user is empty"
+            )
 
         if update_user_dto.new_auth_user is None:
             raise ServiceException(ServiceErrorCode.InvalidData, f"New user is empty")
 
-        if not self._is_email_valid(update_user_dto.auth_user.email) or not self._is_email_valid(
+        if not self._is_email_valid(
-            update_user_dto.new_auth_user.email
+            update_user_dto.auth_user.email
-        ):
+        ) or not self._is_email_valid(update_user_dto.new_auth_user.email):
             raise ServiceException(ServiceErrorCode.InvalidData, f"Invalid E-Mail")
 
         user = self._auth_users.find_auth_user_by_email(update_user_dto.auth_user.email)
@@ -300,7 +333,8 @@ class AuthService(AuthServiceABC):
         # update first name
         if (
             update_user_dto.new_auth_user.first_name is not None
-            and update_user_dto.auth_user.first_name != update_user_dto.new_auth_user.first_name
+            and update_user_dto.auth_user.first_name
+            != update_user_dto.new_auth_user.first_name
         ):
             user.first_name = update_user_dto.new_auth_user.first_name
 
@@ -308,7 +342,8 @@ class AuthService(AuthServiceABC):
         if (
             update_user_dto.new_auth_user.last_name is not None
             and update_user_dto.new_auth_user.last_name != ""
-            and update_user_dto.auth_user.last_name != update_user_dto.new_auth_user.last_name
+            and update_user_dto.auth_user.last_name
+            != update_user_dto.new_auth_user.last_name
         ):
             user.last_name = update_user_dto.new_auth_user.last_name
 
@@ -318,22 +353,33 @@ class AuthService(AuthServiceABC):
             and update_user_dto.new_auth_user.email != ""
             and update_user_dto.auth_user.email != update_user_dto.new_auth_user.email
         ):
-            user_by_new_e_mail = self._auth_users.find_auth_user_by_email(update_user_dto.new_auth_user.email)
+            user_by_new_e_mail = self._auth_users.find_auth_user_by_email(
+                update_user_dto.new_auth_user.email
+            )
             if user_by_new_e_mail is not None:
-                raise ServiceException(ServiceErrorCode.InvalidUser, "User already exists")
+                raise ServiceException(
+                    ServiceErrorCode.InvalidUser, "User already exists"
+                )
             user.email = update_user_dto.new_auth_user.email
 
-        update_user_dto.auth_user.password = self._hash_sha256(update_user_dto.auth_user.password, user.password_salt)
+        update_user_dto.auth_user.password = self._hash_sha256(
+            update_user_dto.auth_user.password, user.password_salt
+        )
         if update_user_dto.auth_user.password != user.password:
             raise ServiceException(ServiceErrorCode.InvalidUser, "Wrong password")
 
         # update password
         if (
             update_user_dto.new_auth_user.password is not None
-            and self._hash_sha256(update_user_dto.new_auth_user.password, user.password_salt) != user.password
+            and self._hash_sha256(
+                update_user_dto.new_auth_user.password, user.password_salt
+            )
+            != user.password
         ):
             user.password_salt = uuid.uuid4()
-            user.password = self._hash_sha256(update_user_dto.new_auth_user.password, user.password_salt)
+            user.password = self._hash_sha256(
+                update_user_dto.new_auth_user.password, user.password_salt
+            )
 
         self._auth_users.update_auth_user(user)
         self._db.save_changes()
@@ -343,23 +389,31 @@ class AuthService(AuthServiceABC):
             raise ServiceException(ServiceErrorCode.InvalidData, f"User is empty")
 
         if update_user_dto.auth_user is None:
-            raise ServiceException(ServiceErrorCode.InvalidData, f"Existing user is empty")
+            raise ServiceException(
+                ServiceErrorCode.InvalidData, f"Existing user is empty"
+            )
 
         if update_user_dto.new_auth_user is None:
             raise ServiceException(ServiceErrorCode.InvalidData, f"New user is empty")
 
-        if not self._is_email_valid(update_user_dto.auth_user.email) or not self._is_email_valid(
+        if not self._is_email_valid(
-            update_user_dto.new_auth_user.email
+            update_user_dto.auth_user.email
-        ):
+        ) or not self._is_email_valid(update_user_dto.new_auth_user.email):
             raise ServiceException(ServiceErrorCode.InvalidData, f"Invalid E-Mail")
 
         user = self._auth_users.find_auth_user_by_email(update_user_dto.auth_user.email)
         if user is None:
             raise ServiceException(ServiceErrorCode.InvalidUser, "User not found")
 
-        if user.confirmation_id is not None and update_user_dto.new_auth_user.is_confirmed:
+        if (
+            user.confirmation_id is not None
+            and update_user_dto.new_auth_user.is_confirmed
+        ):
             user.confirmation_id = None
-        elif user.confirmation_id is None and not update_user_dto.new_auth_user.is_confirmed:
+        elif (
+            user.confirmation_id is None
+            and not update_user_dto.new_auth_user.is_confirmed
+        ):
             user.confirmation_id = uuid.uuid4()
         # else
         #     raise ServiceException(ServiceErrorCode.InvalidUser, 'E-Mail not confirmed')
@@ -367,7 +421,8 @@ class AuthService(AuthServiceABC):
         # update first name
         if (
             update_user_dto.new_auth_user.first_name is not None
-            and update_user_dto.auth_user.first_name != update_user_dto.new_auth_user.first_name
+            and update_user_dto.auth_user.first_name
+            != update_user_dto.new_auth_user.first_name
         ):
             user.first_name = update_user_dto.new_auth_user.first_name
 
@@ -375,7 +430,8 @@ class AuthService(AuthServiceABC):
         if (
             update_user_dto.new_auth_user.last_name is not None
             and update_user_dto.new_auth_user.last_name != ""
-            and update_user_dto.auth_user.last_name != update_user_dto.new_auth_user.last_name
+            and update_user_dto.auth_user.last_name
+            != update_user_dto.new_auth_user.last_name
         ):
             user.last_name = update_user_dto.new_auth_user.last_name
 
@@ -385,19 +441,28 @@ class AuthService(AuthServiceABC):
             and update_user_dto.new_auth_user.email != ""
             and update_user_dto.auth_user.email != update_user_dto.new_auth_user.email
         ):
-            user_by_new_e_mail = self._auth_users.find_auth_user_by_email(update_user_dto.new_auth_user.email)
+            user_by_new_e_mail = self._auth_users.find_auth_user_by_email(
+                update_user_dto.new_auth_user.email
+            )
             if user_by_new_e_mail is not None:
-                raise ServiceException(ServiceErrorCode.InvalidUser, "User already exists")
+                raise ServiceException(
+                    ServiceErrorCode.InvalidUser, "User already exists"
+                )
             user.email = update_user_dto.new_auth_user.email
 
         # update password
         if (
             update_user_dto.new_auth_user.password is not None
             and update_user_dto.change_password
-            and user.password != self._hash_sha256(update_user_dto.new_auth_user.password, user.password_salt)
+            and user.password
+            != self._hash_sha256(
+                update_user_dto.new_auth_user.password, user.password_salt
+            )
         ):
             user.password_salt = uuid.uuid4()
-            user.password = self._hash_sha256(update_user_dto.new_auth_user.password, user.password_salt)
+            user.password = self._hash_sha256(
+                update_user_dto.new_auth_user.password, user.password_salt
+            )
 
         # update role
         if (
@@ -416,7 +481,9 @@ class AuthService(AuthServiceABC):
             self._db.save_changes()
         except Exception as e:
             self._logger.error(__name__, f"Cannot delete user", e)
-            raise ServiceException(ServiceErrorCode.UnableToDelete, f"Cannot delete user by mail {email}")
+            raise ServiceException(
+                ServiceErrorCode.UnableToDelete, f"Cannot delete user by mail {email}"
+            )
 
     async def delete_auth_user_async(self, user_dto: AuthUser):
         try:
@@ -500,7 +567,9 @@ class AuthService(AuthServiceABC):
             if user.id in user_ids:
                 continue
 
-            self._auth_users.add_auth_user_user_rel(AuthUserUsersRelation(db_user, user))
+            self._auth_users.add_auth_user_user_rel(
+                AuthUserUsersRelation(db_user, user)
+            )
 
         if db_user.confirmation_id is not None and not added_user:
             raise ServiceException(ServiceErrorCode.Forbidden, "E-Mail not verified")
@@ -530,13 +599,19 @@ class AuthService(AuthServiceABC):
             ):
                 raise ServiceException(ServiceErrorCode.InvalidData, "Token expired")
 
-            return TokenDTO(self.generate_token(user), self._create_and_save_refresh_token(user))
+            return TokenDTO(
+                self.generate_token(user), self._create_and_save_refresh_token(user)
+            )
         except Exception as e:
             self._logger.error(__name__, f"Refreshing token failed", e)
             return TokenDTO("", "")
 
     async def revoke_async(self, token_dto: TokenDTO):
-        if token_dto is None or token_dto.token is None or token_dto.refresh_token is None:
+        if (
+            token_dto is None
+            or token_dto.token is None
+            or token_dto.refresh_token is None
+        ):
             raise ServiceException(ServiceErrorCode.InvalidData, "Token not set")
 
         try:
@@ -589,7 +664,9 @@ class AuthService(AuthServiceABC):
             )
 
         if user.confirmation_id is not None:
-            raise ServiceException(ServiceErrorCode.InvalidUser, f"E-Mail not confirmed")
+            raise ServiceException(
+                ServiceErrorCode.InvalidUser, f"E-Mail not confirmed"
+            )
 
         if user.password is None or rp_dto.password == "":
             raise ServiceException(ServiceErrorCode.InvalidData, f"Password not set")

bot/src/bot_api/service/discord_service.py

@@ -53,13 +53,17 @@ class DiscordService:
         if role != AuthRoleEnum.admin:
             auth_user = self._auth_users.find_auth_user_by_email(token["email"])
             if auth_user is not None:
-                user_ids = auth_user.users.select(lambda x: x.server is not None and x.server.id)
+                user_ids = auth_user.users.select(
+                    lambda x: x.server is not None and x.server.id
+                )
                 servers = servers.where(lambda x: x.id in user_ids)
 
         servers = List(ServerDTO, servers)
         return servers.select(self._to_dto).where(lambda x: x.name != "")
 
-    async def get_filtered_servers_async(self, criteria: ServerSelectCriteria) -> ServerFilteredResultDTO:
+    async def get_filtered_servers_async(
+        self, criteria: ServerSelectCriteria
+    ) -> ServerFilteredResultDTO:
         token = self._auth.get_decoded_token_from_request()
         if token is None or "email" not in token or "role" not in token:
             raise ServiceException(ServiceErrorCode.InvalidData, "Token invalid")
@@ -70,15 +74,22 @@ class DiscordService:
         if role != AuthRoleEnum.admin:
             auth_user = self._auth_users.find_auth_user_by_email(token["email"])
             if auth_user is not None:
-                user_ids = auth_user.users.select(lambda x: x.server is not None and x.server.id)
+                user_ids = auth_user.users.select(
-                filtered_result.result = filtered_result.result.where(lambda x: x.id in user_ids)
+                    lambda x: x.server is not None and x.server.id
+                )
+                filtered_result.result = filtered_result.result.where(
+                    lambda x: x.id in user_ids
+                )
 
-        servers: List = filtered_result.result.select(self._to_dto).where(lambda x: x.name != "")
+        servers: List = filtered_result.result.select(self._to_dto).where(
+            lambda x: x.name != ""
+        )
         result = List(ServerDTO, servers)
 
         if criteria.name is not None and criteria.name != "":
             result = result.where(
-                lambda x: criteria.name.lower() in x.name.lower() or x.name.lower() == criteria.name.lower()
+                lambda x: criteria.name.lower() in x.name.lower()
+                or x.name.lower() == criteria.name.lower()
             )
 
         return ServerFilteredResultDTO(List(ServerDTO, result), servers.count())
@@ -87,5 +98,7 @@ class DiscordService:
         server = self._servers.get_server_by_id(id)
         guild = self._bot.get_guild(server.discord_id)
 
-        server_dto = ServerTransformer.to_dto(server, guild.name, guild.member_count, guild.icon)
+        server_dto = ServerTransformer.to_dto(
+            server, guild.name, guild.member_count, guild.icon
+        )
         return server_dto

bot/src/bot_api/transformer/auth_user_transformer.py

@@ -27,27 +27,35 @@ class AuthUserTransformer(TransformerABC):
             None,
             None,
             datetime.now(),
-            AuthRoleEnum.normal if dto.auth_role is None else AuthRoleEnum(dto.auth_role),
+            AuthRoleEnum.normal
+            if dto.auth_role is None
+            else AuthRoleEnum(dto.auth_role),
             auth_user_id=0 if dto.id is None else dto.id,
         )
 
     @staticmethod
     @ServiceProviderABC.inject
-    def _is_technician(user: User, bot: DiscordBotServiceABC, permissions: PermissionServiceABC):
+    def _is_technician(
+        user: User, bot: DiscordBotServiceABC, permissions: PermissionServiceABC
+    ):
         guild = bot.get_guild(user.server.discord_id)
         member = guild.get_member(user.discord_id)
         return permissions.is_member_technician(member)
 
     @staticmethod
     @ServiceProviderABC.inject
-    def _is_admin(user: User, bot: DiscordBotServiceABC, permissions: PermissionServiceABC):
+    def _is_admin(
+        user: User, bot: DiscordBotServiceABC, permissions: PermissionServiceABC
+    ):
         guild = bot.get_guild(user.server.discord_id)
         member = guild.get_member(user.discord_id)
         return permissions.is_member_admin(member)
 
     @staticmethod
     @ServiceProviderABC.inject
-    def _is_moderator(user: User, bot: DiscordBotServiceABC, permissions: PermissionServiceABC):
+    def _is_moderator(
+        user: User, bot: DiscordBotServiceABC, permissions: PermissionServiceABC
+    ):
         guild = bot.get_guild(user.server.discord_id)
         member = guild.get_member(user.discord_id)
         return permissions.is_member_moderator(member)

bot/src/bot_api/transformer/server_transformer.py

@@ -13,7 +13,9 @@ class ServerTransformer(TransformerABC):
         return Server(dto.discord_id)
 
     @staticmethod
-    def to_dto(db: Server, name: str, member_count: int, icon_url: Optional[discord.Asset]) -> ServerDTO:
+    def to_dto(
+        db: Server, name: str, member_count: int, icon_url: Optional[discord.Asset]
+    ) -> ServerDTO:
         return ServerDTO(
             db.id,
             db.discord_id,

bot/src/bot_core/abc/client_utils_abc.py

@@ -45,7 +45,9 @@ class ClientUtilsABC(ABC):
         pass
 
     @abstractmethod
-    def get_auto_complete_list(self, _l: List, current: str, select: Callable = None) -> List:
+    def get_auto_complete_list(
+        self, _l: List, current: str, select: Callable = None
+    ) -> List:
         pass
 
     @abstractmethod

bot/src/bot_core/abc/custom_file_logger_abc.py

@@ -18,7 +18,9 @@ class CustomFileLoggerABC(Logger, ABC):
         env: ApplicationEnvironmentABC,
     ):
         self._key = key
-        self._settings: LoggingSettings = config.get_configuration(f"{FileLoggingSettings.__name__}_{key}")
+        self._settings: LoggingSettings = config.get_configuration(
+            f"{FileLoggingSettings.__name__}_{key}"
+        )
         Logger.__init__(self, self._settings, time_format, env)
         self._begin_log()
 
@@ -32,7 +34,9 @@ class CustomFileLoggerABC(Logger, ABC):
         self.info(__name__, f"Starting...")
         self._console = LoggingLevelEnum(console_level)
 
-    def _get_string(self, name_list_as_str: str, level: LoggingLevelEnum, message: str) -> str:
+    def _get_string(
+        self, name_list_as_str: str, level: LoggingLevelEnum, message: str
+    ) -> str:
         names = name_list_as_str.split(" ")
         log_level = level.name
         string = f"<{self._get_datetime_now()}> [ {log_level} ]"

bot/src/bot_core/abc/message_service_abc.py

@@ -13,7 +13,9 @@ class MessageServiceABC(ABC):
         pass
 
     @abstractmethod
-    async def delete_messages(self, messages: List[discord.Message], guild_id: int, without_tracking=False):
+    async def delete_messages(
+        self, messages: List[discord.Message], guild_id: int, without_tracking=False
+    ):
         pass
 
     @abstractmethod

bot/src/bot_core/abc/task_abc.py

@@ -15,7 +15,9 @@ class TaskABC(commands.Cog):
         commands.Cog.__init__(self)
 
     @ServiceProviderABC.inject
-    async def _wait_until_ready(self, config: ConfigurationABC, logger: TaskLogger, bot: DiscordBotServiceABC):
+    async def _wait_until_ready(
+        self, config: ConfigurationABC, logger: TaskLogger, bot: DiscordBotServiceABC
+    ):
         logger.debug(__name__, f"Waiting before {type(self).__name__}")
         await bot.wait_until_ready()
 

bot/src/bot_core/configuration/file_logging_settings.py

@@ -10,7 +10,9 @@ class FileLoggingSettings(LoggingSettings):
         console_log_level: LoggingLevelEnum = None,
         file_log_level: LoggingLevelEnum = None,
     ):
-        LoggingSettings.__init__(self, path, filename, console_log_level, file_log_level)
+        LoggingSettings.__init__(
+            self, path, filename, console_log_level, file_log_level
+        )
 
         self._key = key
 

bot/src/bot_core/core_extension/core_extension.py

@@ -17,7 +17,9 @@ class CoreExtension(ApplicationExtensionABC):
         ApplicationExtensionABC.__init__(self)
 
     async def run(self, config: ConfigurationABC, services: ServiceProviderABC):
-        feature_flags: FeatureFlagsSettings = config.get_configuration(FeatureFlagsSettings)
+        feature_flags: FeatureFlagsSettings = config.get_configuration(
+            FeatureFlagsSettings
+        )
         if not feature_flags.get_flag(FeatureFlagsEnum.core_module):
             return
 

bot/src/bot_core/core_extension/core_extension_module.py

@@ -15,8 +15,14 @@ class CoreExtensionModule(ModuleABC):
     def __init__(self, dc: DiscordCollectionABC):
         ModuleABC.__init__(self, dc, FeatureFlagsEnum.core_extension_module)
 
-    def configure_configuration(self, config: ConfigurationABC, env: ApplicationEnvironmentABC):
+    def configure_configuration(
+        self, config: ConfigurationABC, env: ApplicationEnvironmentABC
+    ):
         pass
 
-    def configure_services(self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC):
+    def configure_services(
-        services.add_transient(DiscordEventTypesEnum.on_ready.value, CoreExtensionOnReadyEvent)
+        self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC
+    ):
+        services.add_transient(
+            DiscordEventTypesEnum.on_ready.value, CoreExtensionOnReadyEvent
+        )

bot/src/bot_core/core_module.py

@@ -20,10 +20,14 @@ class CoreModule(ModuleABC):
     def __init__(self, dc: DiscordCollectionABC):
         ModuleABC.__init__(self, dc, FeatureFlagsEnum.core_module)
 
-    def configure_configuration(self, config: ConfigurationABC, env: ApplicationEnvironmentABC):
+    def configure_configuration(
+        self, config: ConfigurationABC, env: ApplicationEnvironmentABC
+    ):
         pass
 
-    def configure_services(self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC):
+    def configure_services(
+        self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC
+    ):
         services.add_transient(ConfigService)
         services.add_transient(MessageServiceABC, MessageService)
         services.add_transient(ClientUtilsABC, ClientUtilsService)

bot/src/bot_core/helper/command_checks.py

@@ -44,7 +44,9 @@ class CommandChecks:
         async def check_is_member_admin(ctx: Context):
             has_permission = cls._permissions.is_member_admin(ctx.author)
             if not has_permission:
-                await cls._message_service.send_ctx_msg(ctx, cls._t.transform("common.no_permission_message"))
+                await cls._message_service.send_ctx_msg(
+                    ctx, cls._t.transform("common.no_permission_message")
+                )
                 raise CheckError(f"Member {ctx.author.name} is not admin")
 
             return has_permission
@@ -56,7 +58,9 @@ class CommandChecks:
         async def check_is_member_technician(ctx: Context):
             has_permission = cls._permissions.is_member_technician(ctx.author)
             if not has_permission:
-                await cls._message_service.send_ctx_msg(ctx, cls._t.transform("common.no_permission_message"))
+                await cls._message_service.send_ctx_msg(
+                    ctx, cls._t.transform("common.no_permission_message")
+                )
                 raise CheckError(f"Member {ctx.author.name} is not technician")
 
             return has_permission
@@ -68,7 +72,9 @@ class CommandChecks:
         async def check_is_member_moderator(ctx: Context):
             has_permission = cls._permissions.is_member_moderator(ctx.author)
             if not has_permission:
-                await cls._message_service.send_ctx_msg(ctx, cls._t.transform("common.no_permission_message"))
+                await cls._message_service.send_ctx_msg(
+                    ctx, cls._t.transform("common.no_permission_message")
+                )
                 raise CheckError(f"Member {ctx.author.name} is not moderator")
 
             return has_permission

bot/src/bot_core/service/client_utils_service.py

@@ -62,28 +62,36 @@ class ClientUtilsService(ClientUtilsABC):
 
     def received_command(self, guild_id: int):
         server = self._servers.get_server_by_discord_id(guild_id)
-        client = self._clients.find_client_by_discord_id_and_server_id(self._bot.user.id, server.id)
+        client = self._clients.find_client_by_discord_id_and_server_id(
+            self._bot.user.id, server.id
+        )
         client.received_command_count += 1
         self._clients.update_client(client)
         self._db.save_changes()
 
     def moved_user(self, guild_id: int):
         server = self._servers.get_server_by_discord_id(guild_id)
-        client = self._clients.find_client_by_discord_id_and_server_id(self._bot.user.id, server.id)
+        client = self._clients.find_client_by_discord_id_and_server_id(
+            self._bot.user.id, server.id
+        )
         client.moved_users_count += 1
         self._clients.update_client(client)
         self._db.save_changes()
 
     def moved_users(self, guild_id: int, count: int):
         server = self._servers.get_server_by_discord_id(guild_id)
-        client = self._clients.find_client_by_discord_id_and_server_id(self._bot.user.id, server.id)
+        client = self._clients.find_client_by_discord_id_and_server_id(
+            self._bot.user.id, server.id
+        )
         client.moved_users_count += count
         self._clients.update_client(client)
         self._db.save_changes()
 
     def get_client(self, dc_ic: int, guild_id: int):
         server = self._servers.get_server_by_discord_id(guild_id)
-        client = self._clients.find_client_by_discord_id_and_server_id(self._bot.user.id, server.id)
+        client = self._clients.find_client_by_discord_id_and_server_id(
+            self._bot.user.id, server.id
+        )
         return client
 
     async def check_if_bot_is_ready_yet(self) -> bool:
@@ -121,7 +129,9 @@ class ClientUtilsService(ClientUtilsABC):
         await self._bot.change_presence(activity=discord.Game(name=name))
         self._logger.info(__name__, f"Set presence {name}")
 
-    def get_auto_complete_list(self, _l: List, current: str, select: Callable = None) -> List:
+    def get_auto_complete_list(
+        self, _l: List, current: str, select: Callable = None
+    ) -> List:
         if current != "":
             if select is None:
                 select = lambda x: x
@@ -144,7 +154,9 @@ class ClientUtilsService(ClientUtilsABC):
     ) -> bool:
         umcph = None
         try:
-            umcph = self._umcphs.find_user_message_count_per_hour_by_user_id_and_date(user.id, created_at)
+            umcph = self._umcphs.find_user_message_count_per_hour_by_user_id_and_date(
+                user.id, created_at
+            )
             if umcph is None:
                 self._umcphs.add_user_message_count_per_hour(
                     UserMessageCountPerHour(
@@ -157,7 +169,11 @@ class ClientUtilsService(ClientUtilsABC):
 
                 self._db.save_changes()
 
-                umcph = self._umcphs.get_user_message_count_per_hour_by_user_id_and_date(user.id, created_at)
+                umcph = (
+                    self._umcphs.get_user_message_count_per_hour_by_user_id_and_date(
+                        user.id, created_at
+                    )
+                )
         except Exception as e:
             self._logger.error(
                 __name__,
@@ -189,7 +205,9 @@ class ClientUtilsService(ClientUtilsABC):
 
     def get_ontime_for_user(self, user: User) -> float:
         return round(
-            self._user_joined_voice_channel.get_user_joined_voice_channels_by_user_id(user.id)
+            self._user_joined_voice_channel.get_user_joined_voice_channels_by_user_id(
+                user.id
+            )
             .where(lambda x: x.leaved_on is not None and x.joined_on is not None)
             .sum(lambda join: (join.leaved_on - join.joined_on).total_seconds() / 3600),
             2,
@@ -206,7 +224,11 @@ class ClientUtilsService(ClientUtilsABC):
             guild: Guild = self._bot.guilds.where(lambda g: g == guild).single()
             channel = guild.get_channel(discord_channel_id)
             message = await channel.fetch_message(discord_message_id)
-            emoji = List(discord.Emoji, guild.emojis).where(lambda x: x.name == rule.emoji_name).single()
+            emoji = (
+                List(discord.Emoji, guild.emojis)
+                .where(lambda x: x.name == rule.emoji_name)
+                .single()
+            )
 
             if emoji is None:
                 self._logger.debug(__name__, f"Emoji {rule.emoji_name} not found")
@@ -226,7 +248,9 @@ class ClientUtilsService(ClientUtilsABC):
     async def check_default_role(self, member: Union[discord.User, discord.Member]):
         try:
             server = self._servers.get_server_by_discord_id(member.guild.id)
-            settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{server.discord_id}")
+            settings: ServerConfig = self._config.get_configuration(
+                f"ServerConfig_{server.discord_id}"
+            )
 
             if settings.default_role_id is None:
                 return
@@ -238,4 +262,6 @@ class ClientUtilsService(ClientUtilsABC):
             await member.add_roles(default_role)
 
         except Exception as e:
-            self._logger.error(__name__, f"Cannot check for default role for member {member.id}", e)
+            self._logger.error(
+                __name__, f"Cannot check for default role for member {member.id}", e
+            )

bot/src/bot_core/service/data_integrity_service.py

@@ -67,12 +67,16 @@ class DataIntegrityService:
         self._is_for_shutdown = False
 
     def _check_known_users(self):
-        self._logger.debug(__name__, f"Start checking KnownUsers table, {len(self._bot.users)}")
+        self._logger.debug(
+            __name__, f"Start checking KnownUsers table, {len(self._bot.users)}"
+        )
         for u in self._bot.users:
             u: discord.User = u
             try:
                 if u.bot:
-                    self._logger.trace(__name__, f"User {u.id} is ignored, because its a bot")
+                    self._logger.trace(
+                        __name__, f"User {u.id} is ignored, because its a bot"
+                    )
                     continue
 
                 user = self._known_users.find_user_by_discord_id(u.id)
@@ -125,7 +129,9 @@ class DataIntegrityService:
             try:
                 server: Server = self._servers.find_server_by_discord_id(g.id)
                 if server is None:
-                    self._logger.fatal(__name__, f"Server not found in database: {g.id}")
+                    self._logger.fatal(
+                        __name__, f"Server not found in database: {g.id}"
+                    )
 
                 client = self._clients.find_client_by_server_id(server.id)
                 if client is not None:
@@ -136,7 +142,9 @@ class DataIntegrityService:
                     f"Client for server {g.id} not found in database: {self._bot.user.id}",
                 )
                 self._logger.debug(__name__, f"Add client: {self._bot.user.id}")
-                self._clients.add_client(Client(self._bot.user.id, 0, 0, 0, 0, 0, server))
+                self._clients.add_client(
+                    Client(self._bot.user.id, 0, 0, 0, 0, 0, server)
+                )
                 self._db_context.save_changes()
 
                 client = self._clients.find_client_by_server_id(server.id)
@@ -162,15 +170,21 @@ class DataIntegrityService:
             try:
                 server = self._servers.find_server_by_discord_id(g.id)
                 if server is None:
-                    self._logger.fatal(__name__, f"Server not found in database: {g.id}")
+                    self._logger.fatal(
+                        __name__, f"Server not found in database: {g.id}"
+                    )
 
                 for u in g.members:
                     u: Union[discord.Member, discord.User] = u
                     if u.bot:
-                        self._logger.trace(__name__, f"User {u.id} is ignored, because its a bot")
+                        self._logger.trace(
+                            __name__, f"User {u.id} is ignored, because its a bot"
+                        )
                         continue
 
-                    user = self._users.find_user_by_discord_id_and_server_id(u.id, server.id)
+                    user = self._users.find_user_by_discord_id_and_server_id(
+                        u.id, server.id
+                    )
                     if user is not None:
                         continue
 
@@ -194,20 +208,30 @@ class DataIntegrityService:
 
             server = self._servers.find_server_by_discord_id(guild.id)
             if server is None:
-                self._logger.fatal(__name__, f"Server not found in database: {guild.id}")
+                self._logger.fatal(
+                    __name__, f"Server not found in database: {guild.id}"
+                )
 
             try:
                 for u in guild.members:
                     u: discord.User = u
                     if u.bot:
-                        self._logger.trace(__name__, f"User {u.id} is ignored, because its a bot")
+                        self._logger.trace(
+                            __name__, f"User {u.id} is ignored, because its a bot"
+                        )
                         continue
 
-                    user = self._users.find_user_by_discord_id_and_server_id(u.id, server.id)
+                    user = self._users.find_user_by_discord_id_and_server_id(
+                        u.id, server.id
+                    )
                     if user is None:
-                        self._logger.fatal(__name__, f"User not found in database: {u.id}")
+                        self._logger.fatal(
+                            __name__, f"User not found in database: {u.id}"
+                        )
 
-                    join = self._user_joins.find_active_user_joined_server_by_user_id(user.id)
+                    join = self._user_joins.find_active_user_joined_server_by_user_id(
+                        user.id
+                    )
                     if join is not None:
                         continue
 
@@ -257,24 +281,36 @@ class DataIntegrityService:
         self._logger.debug(__name__, f"Start checking UserJoinedVoiceChannel table")
         for guild in self._bot.guilds:
             guild: discord.Guild = guild
-            settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{guild.id}")
+            settings: ServerConfig = self._config.get_configuration(
+                f"ServerConfig_{guild.id}"
+            )
 
             server = self._servers.find_server_by_discord_id(guild.id)
             if server is None:
-                self._logger.fatal(__name__, f"Server not found in database: {guild.id}")
+                self._logger.fatal(
+                    __name__, f"Server not found in database: {guild.id}"
+                )
 
             try:
                 # close open voice states
                 for member in guild.members:
                     if member.bot:
-                        self._logger.trace(__name__, f"User {member.id} is ignored, because its a bot")
+                        self._logger.trace(
+                            __name__, f"User {member.id} is ignored, because its a bot"
+                        )
                         continue
 
-                    user = self._users.find_user_by_discord_id_and_server_id(member.id, server.id)
+                    user = self._users.find_user_by_discord_id_and_server_id(
+                        member.id, server.id
+                    )
                     if user is None:
-                        self._logger.fatal(__name__, f"User not found in database: {member.id}")
+                        self._logger.fatal(
+                            __name__, f"User not found in database: {member.id}"
+                        )
 
-                    joins = self._user_joins_vc.find_active_user_joined_voice_channels_by_user_id(user.id)
+                    joins = self._user_joins_vc.find_active_user_joined_voice_channels_by_user_id(
+                        user.id
+                    )
                     if joins is None or len(joins) == 0:
                         continue
 
@@ -288,7 +324,9 @@ class DataIntegrityService:
                         if (
                             (join.leaved_on - join.joined_on).total_seconds() / 60 / 60
                         ) > settings.max_voice_state_hours:
-                            join.leaved_on = join.joined_on + timedelta(hours=settings.max_voice_state_hours)
+                            join.leaved_on = join.joined_on + timedelta(
+                                hours=settings.max_voice_state_hours
+                            )
 
                         self._user_joins_vc.update_user_joined_voice_channel(join)
 
@@ -303,17 +341,28 @@ class DataIntegrityService:
                 # add open voice states
                 for member in guild.members:
                     if member.bot:
-                        self._logger.trace(__name__, f"User {member.id} is ignored, because its a bot")
+                        self._logger.trace(
+                            __name__, f"User {member.id} is ignored, because its a bot"
+                        )
                         continue
 
-                    if member.voice is None or member.voice.channel.id in settings.afk_channel_ids:
+                    if (
+                        member.voice is None
+                        or member.voice.channel.id in settings.afk_channel_ids
+                    ):
                         continue
 
-                    user = self._users.find_user_by_discord_id_and_server_id(member.id, server.id)
+                    user = self._users.find_user_by_discord_id_and_server_id(
+                        member.id, server.id
+                    )
                     if user is None:
-                        self._logger.fatal(__name__, f"User not found in database: {member.id}")
+                        self._logger.fatal(
+                            __name__, f"User not found in database: {member.id}"
+                        )
 
-                    join = UserJoinedVoiceChannel(user, member.voice.channel.id, datetime.now())
+                    join = UserJoinedVoiceChannel(
+                        user, member.voice.channel.id, datetime.now()
+                    )
                     self._user_joins_vc.add_user_joined_voice_channel(join)
                     self._db_context.save_changes()
 
@@ -327,19 +376,29 @@ class DataIntegrityService:
 
             server = self._servers.find_server_by_discord_id(guild.id)
             if server is None:
-                self._logger.fatal(__name__, f"Server not found in database: {guild.id}")
+                self._logger.fatal(
+                    __name__, f"Server not found in database: {guild.id}"
+                )
 
             try:
                 for member in guild.members:
                     if member.bot:
-                        self._logger.trace(__name__, f"User {member.id} is ignored, because its a bot")
+                        self._logger.trace(
+                            __name__, f"User {member.id} is ignored, because its a bot"
+                        )
                         continue
 
-                    user = self._users.find_user_by_discord_id_and_server_id(member.id, server.id)
+                    user = self._users.find_user_by_discord_id_and_server_id(
+                        member.id, server.id
+                    )
                     if user is None:
-                        self._logger.fatal(__name__, f"User not found in database: {member.id}")
+                        self._logger.fatal(
+                            __name__, f"User not found in database: {member.id}"
+                        )
 
-                    joins = self._user_joined_gs.find_active_user_joined_game_servers_by_user_id(user.id)
+                    joins = self._user_joined_gs.find_active_user_joined_game_servers_by_user_id(
+                        user.id
+                    )
                     if joins is None or len(joins) == 0:
                         continue
 
@@ -349,12 +408,16 @@ class DataIntegrityService:
                             f"Active UserJoinedGameServer found in database: {guild.id}:{member.id}@{join.joined_on}",
                         )
                         join.leaved_on = datetime.now()
-                        settings: ServerConfig = self._config.get_configuration(f"ServerConfig_{guild.id}")
+                        settings: ServerConfig = self._config.get_configuration(
+                            f"ServerConfig_{guild.id}"
+                        )
 
                         if (
                             (join.leaved_on - join.joined_on).total_seconds() / 60 / 60
                         ) > settings.max_voice_state_hours:
-                            join.leaved_on = join.joined_on + timedelta(hours=settings.max_voice_state_hours)
+                            join.leaved_on = join.joined_on + timedelta(
+                                hours=settings.max_voice_state_hours
+                            )
 
                         self._user_joined_gs.update_user_joined_game_server(join)
                         if self._is_for_shutdown:
@@ -371,16 +434,24 @@ class DataIntegrityService:
         for guild in self._bot.guilds:
             server = self._servers.find_server_by_discord_id(guild.id)
             if server is None:
-                self._logger.fatal(__name__, f"Server not found in database: {guild.id}")
+                self._logger.fatal(
+                    __name__, f"Server not found in database: {guild.id}"
+                )
 
             for member in guild.members:
                 if member.bot:
-                    self._logger.trace(__name__, f"User {member.id} is ignored, because its a bot")
+                    self._logger.trace(
+                        __name__, f"User {member.id} is ignored, because its a bot"
+                    )
                     continue
 
-                user = self._users.find_user_by_discord_id_and_server_id(member.id, server.id)
+                user = self._users.find_user_by_discord_id_and_server_id(
+                    member.id, server.id
+                )
                 if user is None:
-                    self._logger.fatal(__name__, f"User not found in database: {member.id}")
+                    self._logger.fatal(
+                        __name__, f"User not found in database: {member.id}"
+                    )
 
                 await self._achievements.validate_achievements_for_user(user)
 

bot/src/bot_core/service/message_service.py

@@ -31,15 +31,23 @@ class MessageService(MessageServiceABC):
         self._clients = clients
         self._db = db
 
-    async def delete_messages(self, messages: List[discord.Message], guild_id: int, without_tracking=False):
+    async def delete_messages(
+        self, messages: List[discord.Message], guild_id: int, without_tracking=False
+    ):
         self._logger.debug(__name__, f"Try to delete {messages.count()} messages")
-        server_st: ServerConfig = self._config.get_configuration(f"ServerConfig_{guild_id}")
+        server_st: ServerConfig = self._config.get_configuration(
+            f"ServerConfig_{guild_id}"
+        )
         await asyncio.sleep(server_st.message_delete_timer)
         for message in messages:
-            await self.delete_message(message, mass_delete=True, without_tracking=without_tracking)
+            await self.delete_message(
+                message, mass_delete=True, without_tracking=without_tracking
+            )
         self._logger.debug(__name__, "Deleting messages finished")
 
-    async def delete_message(self, message: discord.Message, mass_delete=False, without_tracking=False):
+    async def delete_message(
+        self, message: discord.Message, mass_delete=False, without_tracking=False
+    ):
         guild_id = (
             message.guild.id
             if message.guild is not None
@@ -50,7 +58,9 @@ class MessageService(MessageServiceABC):
             else None
         )
 
-        server_st: ServerConfig = self._config.get_configuration(f"ServerConfig_{guild_id}")
+        server_st: ServerConfig = self._config.get_configuration(
+            f"ServerConfig_{guild_id}"
+        )
         if not mass_delete:
             await asyncio.sleep(server_st.message_delete_timer)
         self._logger.debug(
@@ -64,7 +74,9 @@ class MessageService(MessageServiceABC):
             self._logger.error(__name__, f"Deleting message failed", e)
         else:
             if not without_tracking:
-                self._clients.append_deleted_message_count(self._bot.user.id, guild_id, 1)
+                self._clients.append_deleted_message_count(
+                    self._bot.user.id, guild_id, 1
+                )
                 self._db.save_changes()
             self._logger.info(__name__, f"Deleted message {message}")
 
@@ -76,7 +88,9 @@ class MessageService(MessageServiceABC):
         wait_before_delete: int = None,
         without_tracking=False,
     ):
-        self._logger.debug(__name__, f"Try to send message\n\t{message}\n\tto: {channel}")
+        self._logger.debug(
+            __name__, f"Try to send message\n\t{message}\n\tto: {channel}"
+        )
         msg = None
         try:
             if isinstance(message, discord.Embed):
@@ -86,11 +100,15 @@ class MessageService(MessageServiceABC):
             else:
                 msg = await channel.send(message)
         except Exception as e:
-            self._logger.error(__name__, f"Send message to channel {channel.id} failed", e)
+            self._logger.error(
+                __name__, f"Send message to channel {channel.id} failed", e
+            )
         else:
             self._logger.info(__name__, f"Sent message to channel {channel.id}")
             if not without_tracking:
-                self._clients.append_sent_message_count(self._bot.user.id, channel.guild.id, 1)
+                self._clients.append_sent_message_count(
+                    self._bot.user.id, channel.guild.id, 1
+                )
                 self._db.save_changes()
 
             if wait_before_delete is not None:
@@ -107,17 +125,23 @@ class MessageService(MessageServiceABC):
         receiver: Union[discord.User, discord.Member],
         without_tracking=False,
     ):
-        self._logger.debug(__name__, f"Try to send message\n\t{message}\n\tto: {receiver}")
+        self._logger.debug(
+            __name__, f"Try to send message\n\t{message}\n\tto: {receiver}"
+        )
         try:
             if isinstance(message, discord.Embed):
                 msg = await receiver.send(embed=message)
             else:
                 msg = await receiver.send(message)
         except Exception as e:
-            self._logger.error(__name__, f"Send message to user {receiver.id} failed", e)
+            self._logger.error(
+                __name__, f"Send message to user {receiver.id} failed", e
+            )
         else:
             if not without_tracking:
-                self._clients.append_sent_message_count(self._bot.user.id, receiver.guild.id, 1)
+                self._clients.append_sent_message_count(
+                    self._bot.user.id, receiver.guild.id, 1
+                )
                 self._db.save_changes()
             self._logger.info(__name__, f"Sent message to user {receiver.id}")
 
@@ -136,7 +160,9 @@ class MessageService(MessageServiceABC):
             self._logger.debug(__name__, f"Message: {message}")
             return None
 
-        self._logger.debug(__name__, f"Try to send message\t\t{message}\n\tto: {ctx.channel}")
+        self._logger.debug(
+            __name__, f"Try to send message\t\t{message}\n\tto: {ctx.channel}"
+        )
         msg = None
         try:
             if isinstance(message, discord.Embed):
@@ -144,11 +170,15 @@ class MessageService(MessageServiceABC):
             else:
                 msg = await ctx.send(message, file=file, ephemeral=not is_public)
         except Exception as e:
-            self._logger.error(__name__, f"Send message to channel {ctx.channel.id} failed", e)
+            self._logger.error(
+                __name__, f"Send message to channel {ctx.channel.id} failed", e
+            )
         else:
             self._logger.info(__name__, f"Sent message to channel {ctx.channel.id}")
             if not without_tracking and ctx.guild is not None:
-                self._clients.append_sent_message_count(self._bot.user.id, ctx.guild.id, 1)
+                self._clients.append_sent_message_count(
+                    self._bot.user.id, ctx.guild.id, 1
+                )
                 self._db.save_changes()
 
             if wait_before_delete is not None:
@@ -177,18 +207,30 @@ class MessageService(MessageServiceABC):
             self._logger.debug(__name__, f"Message: {message}")
             return
 
-        self._logger.debug(__name__, f"Try to send message\t\t{message}\n\tto: {interaction.channel}")
+        self._logger.debug(
+            __name__, f"Try to send message\t\t{message}\n\tto: {interaction.channel}"
+        )
         try:
             if isinstance(message, discord.Embed):
-                await interaction.response.send_message(embed=message, ephemeral=not is_public, **kwargs)
+                await interaction.response.send_message(
+                    embed=message, ephemeral=not is_public, **kwargs
+                )
             else:
-                await interaction.response.send_message(message, ephemeral=not is_public, **kwargs)
+                await interaction.response.send_message(
+                    message, ephemeral=not is_public, **kwargs
+                )
         except Exception as e:
-            self._logger.error(__name__, f"Send message to channel {interaction.channel.id} failed", e)
+            self._logger.error(
+                __name__, f"Send message to channel {interaction.channel.id} failed", e
+            )
         else:
-            self._logger.info(__name__, f"Sent message to channel {interaction.channel.id}")
+            self._logger.info(
+                __name__, f"Sent message to channel {interaction.channel.id}"
+            )
             if not without_tracking and interaction.guild is not None:
-                self._clients.append_sent_message_count(self._bot.user.id, interaction.guild.id, 1)
+                self._clients.append_sent_message_count(
+                    self._bot.user.id, interaction.guild.id, 1
+                )
                 self._db.save_changes()
 
             if wait_before_delete is not None:
@@ -197,4 +239,6 @@ class MessageService(MessageServiceABC):
             if is_persistent:
                 return
 
-            await self.delete_message(await interaction.original_response(), without_tracking)
+            await self.delete_message(
+                await interaction.original_response(), without_tracking
+            )

bot/src/bot_data/abc/achievement_repository_abc.py

@@ -28,7 +28,9 @@ class AchievementRepositoryABC(ABC):
         pass
 
     @abstractmethod
-    def get_user_got_achievements_by_achievement_id(self, achievement_id: int) -> List[Achievement]:
+    def get_user_got_achievements_by_achievement_id(
+        self, achievement_id: int
+    ) -> List[Achievement]:
         pass
 
     @abstractmethod

bot/src/bot_data/abc/auth_user_repository_abc.py

@@ -23,7 +23,9 @@ class AuthUserRepositoryABC(ABC):
         pass
 
     @abstractmethod
-    def get_filtered_auth_users(self, criteria: AuthUserSelectCriteria) -> FilteredResult:
+    def get_filtered_auth_users(
+        self, criteria: AuthUserSelectCriteria
+    ) -> FilteredResult:
         pass
 
     @abstractmethod

bot/src/bot_data/abc/client_repository_abc.py

@@ -36,7 +36,9 @@ class ClientRepositoryABC(ABC):
         pass
 
     @abstractmethod
-    def find_client_by_discord_id_and_server_id(self, discord_id: int, server_id: int) -> Optional[Client]:
+    def find_client_by_discord_id_and_server_id(
+        self, discord_id: int, server_id: int
+    ) -> Optional[Client]:
         pass
 
     @abstractmethod

bot/src/bot_data/abc/server_config_repository_abc.py

@@ -35,25 +35,37 @@ class ServerConfigRepositoryABC(ABC):
         pass
 
     @abstractmethod
-    def add_server_team_role_id_config(self, server_team_role_id: ServerTeamRoleIdsConfig):
+    def add_server_team_role_id_config(
+        self, server_team_role_id: ServerTeamRoleIdsConfig
+    ):
         pass
 
     @abstractmethod
-    def update_server_team_role_id_config(self, server_team_role_id: ServerTeamRoleIdsConfig):
+    def update_server_team_role_id_config(
+        self, server_team_role_id: ServerTeamRoleIdsConfig
+    ):
         pass
 
     @abstractmethod
-    def delete_server_team_role_id_config(self, server_team_role_id: ServerTeamRoleIdsConfig):
+    def delete_server_team_role_id_config(
+        self, server_team_role_id: ServerTeamRoleIdsConfig
+    ):
         pass
 
     @abstractmethod
-    def add_server_afk_channel_config(self, server_afk_channel: ServerAFKChannelIdsConfig):
+    def add_server_afk_channel_config(
+        self, server_afk_channel: ServerAFKChannelIdsConfig
+    ):
         pass
 
     @abstractmethod
-    def update_server_afk_channel_config(self, server_afk_channel: ServerAFKChannelIdsConfig):
+    def update_server_afk_channel_config(
+        self, server_afk_channel: ServerAFKChannelIdsConfig
+    ):
         pass
 
     @abstractmethod
-    def delete_server_afk_channel_config(self, server_afk_channel: ServerAFKChannelIdsConfig):
+    def delete_server_afk_channel_config(
+        self, server_afk_channel: ServerAFKChannelIdsConfig
+    ):
         pass

bot/src/bot_data/abc/technician_config_repository_abc.py

@@ -43,13 +43,19 @@ class TechnicianConfigRepositoryABC(ABC):
         pass
 
     @abstractmethod
-    def add_technician_ping_url_config(self, technician_ping_url: TechnicianPingUrlConfig):
+    def add_technician_ping_url_config(
+        self, technician_ping_url: TechnicianPingUrlConfig
+    ):
         pass
 
     @abstractmethod
-    def update_technician_ping_url_config(self, technician_ping_url: TechnicianPingUrlConfig):
+    def update_technician_ping_url_config(
+        self, technician_ping_url: TechnicianPingUrlConfig
+    ):
         pass
 
     @abstractmethod
-    def delete_technician_ping_url_config(self, technician_ping_url: TechnicianPingUrlConfig):
+    def delete_technician_ping_url_config(
+        self, technician_ping_url: TechnicianPingUrlConfig
+    ):
         pass

bot/src/bot_data/abc/user_joined_game_server_repository_abc.py

@@ -20,31 +20,45 @@ class UserJoinedGameServerRepositoryABC(ABC):
         pass
 
     @abstractmethod
-    def get_user_joined_game_servers_by_user_id(self, user_id: int) -> List[UserJoinedGameServer]:
+    def get_user_joined_game_servers_by_user_id(
+        self, user_id: int
+    ) -> List[UserJoinedGameServer]:
         pass
 
     @abstractmethod
-    def get_active_user_joined_game_server_by_user_id(self, user_id: int) -> UserJoinedGameServer:
+    def get_active_user_joined_game_server_by_user_id(
+        self, user_id: int
+    ) -> UserJoinedGameServer:
         pass
 
     @abstractmethod
-    def find_active_user_joined_game_server_by_user_id(self, user_id: int) -> Optional[UserJoinedGameServer]:
+    def find_active_user_joined_game_server_by_user_id(
+        self, user_id: int
+    ) -> Optional[UserJoinedGameServer]:
         pass
 
     @abstractmethod
-    def find_active_user_joined_game_servers_by_user_id(self, user_id: int) -> List[Optional[UserJoinedGameServer]]:
+    def find_active_user_joined_game_servers_by_user_id(
+        self, user_id: int
+    ) -> List[Optional[UserJoinedGameServer]]:
         pass
 
     @abstractmethod
-    def add_user_joined_game_server(self, user_joined_game_server: UserJoinedGameServer):
+    def add_user_joined_game_server(
+        self, user_joined_game_server: UserJoinedGameServer
+    ):
         pass
 
     @abstractmethod
-    def update_user_joined_game_server(self, user_joined_game_server: UserJoinedGameServer):
+    def update_user_joined_game_server(
+        self, user_joined_game_server: UserJoinedGameServer
+    ):
         pass
 
     @abstractmethod
-    def delete_user_joined_game_server(self, user_joined_game_server: UserJoinedGameServer):
+    def delete_user_joined_game_server(
+        self, user_joined_game_server: UserJoinedGameServer
+    ):
         pass
 
     @abstractmethod

bot/src/bot_data/abc/user_joined_server_repository_abc.py

@@ -24,15 +24,21 @@ class UserJoinedServerRepositoryABC(ABC):
         pass
 
     @abstractmethod
-    def get_user_joined_servers_by_user_id(self, user_id: int) -> list[UserJoinedServer]:
+    def get_user_joined_servers_by_user_id(
+        self, user_id: int
+    ) -> list[UserJoinedServer]:
         pass
 
     @abstractmethod
-    def get_active_user_joined_server_by_user_id(self, user_id: int) -> UserJoinedServer:
+    def get_active_user_joined_server_by_user_id(
+        self, user_id: int
+    ) -> UserJoinedServer:
         pass
 
     @abstractmethod
-    def find_active_user_joined_server_by_user_id(self, user_id: int) -> Optional[UserJoinedServer]:
+    def find_active_user_joined_server_by_user_id(
+        self, user_id: int
+    ) -> Optional[UserJoinedServer]:
         pass
 
     @abstractmethod

bot/src/bot_data/abc/user_joined_voice_channel_repository_abc.py

@@ -19,31 +19,45 @@ class UserJoinedVoiceChannelRepositoryABC(ABC):
         pass
 
     @abstractmethod
-    def get_user_joined_voice_channels_by_user_id(self, user_id: int) -> List[UserJoinedVoiceChannel]:
+    def get_user_joined_voice_channels_by_user_id(
+        self, user_id: int
+    ) -> List[UserJoinedVoiceChannel]:
         pass
 
     @abstractmethod
-    def get_active_user_joined_voice_channel_by_user_id(self, user_id: int) -> UserJoinedVoiceChannel:
+    def get_active_user_joined_voice_channel_by_user_id(
+        self, user_id: int
+    ) -> UserJoinedVoiceChannel:
         pass
 
     @abstractmethod
-    def find_active_user_joined_voice_channel_by_user_id(self, user_id: int) -> Optional[UserJoinedVoiceChannel]:
+    def find_active_user_joined_voice_channel_by_user_id(
+        self, user_id: int
+    ) -> Optional[UserJoinedVoiceChannel]:
         pass
 
     @abstractmethod
-    def find_active_user_joined_voice_channels_by_user_id(self, user_id: int) -> List[Optional[UserJoinedVoiceChannel]]:
+    def find_active_user_joined_voice_channels_by_user_id(
+        self, user_id: int
+    ) -> List[Optional[UserJoinedVoiceChannel]]:
         pass
 
     @abstractmethod
-    def add_user_joined_voice_channel(self, user_joined_voice_channel: UserJoinedVoiceChannel):
+    def add_user_joined_voice_channel(
+        self, user_joined_voice_channel: UserJoinedVoiceChannel
+    ):
         pass
 
     @abstractmethod
-    def update_user_joined_voice_channel(self, user_joined_voice_channel: UserJoinedVoiceChannel):
+    def update_user_joined_voice_channel(
+        self, user_joined_voice_channel: UserJoinedVoiceChannel
+    ):
         pass
 
     @abstractmethod
-    def delete_user_joined_voice_channel(self, user_joined_voice_channel: UserJoinedVoiceChannel):
+    def delete_user_joined_voice_channel(
+        self, user_joined_voice_channel: UserJoinedVoiceChannel
+    ):
         pass
 
     @abstractmethod

bot/src/bot_data/abc/user_message_count_per_hour_repository_abc.py

@@ -17,7 +17,9 @@ class UserMessageCountPerHourRepositoryABC(ABC):
         pass
 
     @abstractmethod
-    def find_user_message_count_per_hour_by_user_id(self, user_id: int) -> Optional[UserMessageCountPerHour]:
+    def find_user_message_count_per_hour_by_user_id(
+        self, user_id: int
+    ) -> Optional[UserMessageCountPerHour]:
         pass
 
     @abstractmethod

bot/src/bot_data/abc/user_repository_abc.py

@@ -32,11 +32,15 @@ class UserRepositoryABC(ABC):
         pass
 
     @abstractmethod
-    def get_user_by_discord_id_and_server_id(self, discord_id: int, server_id: int) -> User:
+    def get_user_by_discord_id_and_server_id(
+        self, discord_id: int, server_id: int
+    ) -> User:
         pass
 
     @abstractmethod
-    def find_user_by_discord_id_and_server_id(self, discord_id: int, server_id: int) -> Optional[User]:
+    def find_user_by_discord_id_and_server_id(
+        self, discord_id: int, server_id: int
+    ) -> Optional[User]:
         pass
 
     @abstractmethod

bot/src/bot_data/data_module.py

@@ -86,10 +86,14 @@ class DataModule(ModuleABC):
     def __init__(self, dc: DiscordCollectionABC):
         ModuleABC.__init__(self, dc, FeatureFlagsEnum.data_module)
 
-    def configure_configuration(self, config: ConfigurationABC, env: ApplicationEnvironmentABC):
+    def configure_configuration(
+        self, config: ConfigurationABC, env: ApplicationEnvironmentABC
+    ):
         pass
 
-    def configure_services(self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC):
+    def configure_services(
+        self, services: ServiceCollectionABC, env: ApplicationEnvironmentABC
+    ):
         services.add_singleton(CacheService)
 
         services.add_transient(ApiKeyRepositoryABC, ApiKeyRepositoryService)
@@ -98,9 +102,15 @@ class DataModule(ModuleABC):
         services.add_transient(UserRepositoryABC, UserRepositoryService)
         services.add_transient(ClientRepositoryABC, ClientRepositoryService)
         services.add_transient(KnownUserRepositoryABC, KnownUserRepositoryService)
-        services.add_transient(UserJoinedServerRepositoryABC, UserJoinedServerRepositoryService)
+        services.add_transient(
-        services.add_transient(UserJoinedVoiceChannelRepositoryABC, UserJoinedVoiceChannelRepositoryService)
+            UserJoinedServerRepositoryABC, UserJoinedServerRepositoryService
-        services.add_transient(UserJoinedGameServerRepositoryABC, UserJoinedGameServerRepositoryService)
+        )
+        services.add_transient(
+            UserJoinedVoiceChannelRepositoryABC, UserJoinedVoiceChannelRepositoryService
+        )
+        services.add_transient(
+            UserJoinedGameServerRepositoryABC, UserJoinedGameServerRepositoryService
+        )
         services.add_transient(AutoRoleRepositoryABC, AutoRoleRepositoryService)
         services.add_transient(LevelRepositoryABC, LevelRepositoryService)
         services.add_transient(UserWarningsRepositoryABC, UserWarningsRepositoryService)
@@ -109,12 +119,20 @@ class DataModule(ModuleABC):
             UserMessageCountPerHourRepositoryService,
         )
         services.add_transient(GameServerRepositoryABC, GameServerRepositoryService)
-        services.add_transient(UserGameIdentRepositoryABC, UserGameIdentRepositoryService)
+        services.add_transient(
+            UserGameIdentRepositoryABC, UserGameIdentRepositoryService
+        )
         services.add_transient(AchievementRepositoryABC, AchievementRepositoryService)
-        services.add_transient(TechnicianConfigRepositoryABC, TechnicianConfigRepositoryService)
+        services.add_transient(
+            TechnicianConfigRepositoryABC, TechnicianConfigRepositoryService
+        )
         services.add_transient(ServerConfigRepositoryABC, ServerConfigRepositoryService)
-        services.add_transient(ShortRoleNameRepositoryABC, ShortRoleNameRepositoryService)
+        services.add_transient(
-        services.add_transient(SteamSpecialOfferRepositoryABC, SteamSpecialOfferRepositoryService)
+            ShortRoleNameRepositoryABC, ShortRoleNameRepositoryService
+        )
+        services.add_transient(
+            SteamSpecialOfferRepositoryABC, SteamSpecialOfferRepositoryService
+        )
 
         services.add_transient(SeederService)
         services.add_transient(DataSeederABC, TechnicianConfigSeeder)

bot/src/bot_data/migration/achievements_migration.py

@@ -74,12 +74,30 @@ class AchievementsMigration(MigrationABC):
 
         # A join table history between users and achievements is not necessary.
 
-        self._cursor.execute(str(f"""ALTER TABLE Users ADD MessageCount BIGINT NOT NULL DEFAULT 0 AFTER XP;"""))
+        self._cursor.execute(
-        self._cursor.execute(str(f"""ALTER TABLE Users ADD ReactionCount BIGINT NOT NULL DEFAULT 0 AFTER XP;"""))
+            str(
-        self._cursor.execute(str(f"""ALTER TABLE UsersHistory ADD MessageCount BIGINT NOT NULL DEFAULT 0 AFTER XP;"""))
+                f"""ALTER TABLE Users ADD MessageCount BIGINT NOT NULL DEFAULT 0 AFTER XP;"""
-        self._cursor.execute(str(f"""ALTER TABLE UsersHistory ADD ReactionCount BIGINT NOT NULL DEFAULT 0 AFTER XP;"""))
+            )
+        )
+        self._cursor.execute(
+            str(
+                f"""ALTER TABLE Users ADD ReactionCount BIGINT NOT NULL DEFAULT 0 AFTER XP;"""
+            )
+        )
+        self._cursor.execute(
+            str(
+                f"""ALTER TABLE UsersHistory ADD MessageCount BIGINT NOT NULL DEFAULT 0 AFTER XP;"""
+            )
+        )
+        self._cursor.execute(
+            str(
+                f"""ALTER TABLE UsersHistory ADD ReactionCount BIGINT NOT NULL DEFAULT 0 AFTER XP;"""
+            )
+        )
 
-        self._cursor.execute(str(f"""DROP TRIGGER IF EXISTS `TR_AchievementsUpdate`;"""))
+        self._cursor.execute(
+            str(f"""DROP TRIGGER IF EXISTS `TR_AchievementsUpdate`;""")
+        )
         self._cursor.execute(
             str(
                 f"""
@@ -99,7 +117,9 @@ class AchievementsMigration(MigrationABC):
             )
         )
 
-        self._cursor.execute(str(f"""DROP TRIGGER IF EXISTS `TR_AchievementsDelete`;"""))
+        self._cursor.execute(
+            str(f"""DROP TRIGGER IF EXISTS `TR_AchievementsDelete`;""")
+        )
 
         self._cursor.execute(
             str(

bot/src/bot_data/migration/config_feature_flags_migration.py

@@ -16,11 +16,15 @@ class ConfigFeatureFlagsMigration(MigrationABC):
         self._logger.debug(__name__, "Running upgrade")
 
         self._cursor.execute(
-            str("""ALTER TABLE CFG_Technician ADD FeatureFlags JSON NULL DEFAULT ('{}') AFTER CacheMaxMessages;""")
+            str(
+                """ALTER TABLE CFG_Technician ADD FeatureFlags JSON NULL DEFAULT ('{}') AFTER CacheMaxMessages;"""
+            )
         )
 
         self._cursor.execute(
-            str("""ALTER TABLE CFG_Server ADD FeatureFlags JSON NULL DEFAULT ('{}') AFTER LoginMessageChannelId;""")
+            str(
+                """ALTER TABLE CFG_Server ADD FeatureFlags JSON NULL DEFAULT ('{}') AFTER LoginMessageChannelId;"""
+            )
         )
 
     def downgrade(self):

bot/src/bot_data/migration/fix_updates_migration.py

@@ -47,5 +47,7 @@ class FixUpdatesMigration(MigrationABC):
                 """
             )
         )
-        self._cursor.execute("ALTER TABLE CFG_TechnicianHistory DROP COLUMN FeatureFlags;")
+        self._cursor.execute(
+            "ALTER TABLE CFG_TechnicianHistory DROP COLUMN FeatureFlags;"
+        )
         self._cursor.execute("ALTER TABLE CFG_ServerHistory DROP COLUMN FeatureFlags;")

bot/src/bot_data/model/achievement.py

@@ -34,7 +34,9 @@ class Achievement(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @ServiceProviderABC.inject
     def _is_operator_valid(self, operator, service: ServiceProviderABC) -> bool:

bot/src/bot_data/model/api_key.py

@@ -23,7 +23,9 @@ class ApiKey(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/auth_user.py

@@ -49,7 +49,9 @@ class AuthUser(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/auth_user_users_relation.py

@@ -19,7 +19,9 @@ class AuthUserUsersRelation(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def auth_user(self) -> AuthUser:

bot/src/bot_data/model/auto_role.py

@@ -25,7 +25,9 @@ class AutoRole(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/auto_role_rule.py

@@ -24,7 +24,9 @@ class AutoRoleRule(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/client.py

@@ -32,7 +32,9 @@ class Client(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/game_server.py

@@ -23,7 +23,9 @@ class GameServer(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/known_user.py

@@ -16,7 +16,9 @@ class KnownUser(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/level.py

@@ -27,7 +27,9 @@ class Level(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/server.py

@@ -18,7 +18,9 @@ class Server(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/server_afk_channel_ids_config.py

@@ -18,7 +18,9 @@ class ServerAFKChannelIdsConfig(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def channel_id(self) -> int:

bot/src/bot_data/model/server_config.py

@@ -56,7 +56,9 @@ class ServerConfig(TableABC, ConfigurationModelABC):
         self._team_channel_id = team_channel_id
         self._login_message_channel_id = login_message_channel_id
         self._default_role_id = default_role_id
-        self._short_role_name_only_set_highest_role = short_role_name_only_set_highest_role
+        self._short_role_name_only_set_highest_role = (
+            short_role_name_only_set_highest_role
+        )
         self._game_offer_notification_chat_id = game_offer_notification_chat_id
 
         self._feature_flags = feature_flags
@@ -66,7 +68,9 @@ class ServerConfig(TableABC, ConfigurationModelABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @staticmethod
     def new(guild: Guild, server: Server) -> "ServerConfig":

bot/src/bot_data/model/server_config_history.py

@@ -43,7 +43,9 @@ class ServerConfigHistory(HistoryTableABC):
         self._team_channel_id = team_channel_id
         self._login_message_channel_id = login_message_channel_id
         self._default_role_id = default_role_id
-        self._short_role_name_only_set_highest_role = short_role_name_only_set_highest_role
+        self._short_role_name_only_set_highest_role = (
+            short_role_name_only_set_highest_role
+        )
 
         self._feature_flags = feature_flags
         self._server_id = server_id

bot/src/bot_data/model/server_team_role_ids_config.py

@@ -22,7 +22,9 @@ class ServerTeamRoleIdsConfig(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/short_role_name.py

@@ -27,7 +27,9 @@ class ShortRoleName(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/steam_special_offer.py

@@ -22,7 +22,9 @@ class SteamSpecialOffer(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/technician_config.py

@@ -33,7 +33,9 @@ class TechnicianConfig(TableABC, ConfigurationModelABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/technician_id_config.py

@@ -16,7 +16,9 @@ class TechnicianIdConfig(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/technician_ping_url_config.py

@@ -16,7 +16,9 @@ class TechnicianPingUrlConfig(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/user.py

@@ -33,7 +33,9 @@ class User(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:
@@ -119,7 +121,9 @@ class User(TableABC):
             UserJoinedServerRepositoryABC,
         )
 
-        ujs: UserJoinedServerRepositoryABC = services.get_service(UserJoinedServerRepositoryABC)
+        ujs: UserJoinedServerRepositoryABC = services.get_service(
+            UserJoinedServerRepositoryABC
+        )
         return ujs.find_active_user_joined_server_by_user_id(self.id) is None
 
     @property
@@ -132,7 +136,9 @@ class User(TableABC):
             UserGameIdentRepositoryABC,
         )
 
-        game_idents_repo: UserGameIdentRepositoryABC = services.get_service(UserGameIdentRepositoryABC)
+        game_idents_repo: UserGameIdentRepositoryABC = services.get_service(
+            UserGameIdentRepositoryABC
+        )
         return game_idents_repo.get_user_game_idents_by_user_id(self.id)
 
     @staticmethod

bot/src/bot_data/model/user_game_ident.py

@@ -23,7 +23,9 @@ class UserGameIdent(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/user_got_achievement.py

@@ -22,7 +22,9 @@ class UserGotAchievement(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/user_history.py

@@ -64,7 +64,9 @@ class UserHistory(HistoryTableABC):
             UserJoinedServerRepositoryABC,
         )
 
-        ujs: UserJoinedServerRepositoryABC = services.get_service(UserJoinedServerRepositoryABC)
+        ujs: UserJoinedServerRepositoryABC = services.get_service(
+            UserJoinedServerRepositoryABC
+        )
         return ujs.find_active_user_joined_server_by_user_id(self.id) is None
 
     @property
@@ -77,5 +79,7 @@ class UserHistory(HistoryTableABC):
             UserGameIdentRepositoryABC,
         )
 
-        game_idents_repo: UserGameIdentRepositoryABC = services.get_service(UserGameIdentRepositoryABC)
+        game_idents_repo: UserGameIdentRepositoryABC = services.get_service(
+            UserGameIdentRepositoryABC
+        )
         return game_idents_repo.get_user_game_idents_by_user_id(self.id)

bot/src/bot_data/model/user_joined_game_server.py

@@ -25,7 +25,9 @@ class UserJoinedGameServer(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/user_joined_server.py

@@ -22,7 +22,9 @@ class UserJoinedServer(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/user_joined_voice_channel.py

@@ -26,7 +26,9 @@ class UserJoinedVoiceChannel(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/user_message_count_per_hour.py

@@ -24,7 +24,9 @@ class UserMessageCountPerHour(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/model/user_warnings.py

@@ -24,7 +24,9 @@ class UserWarnings(TableABC):
 
         TableABC.__init__(self)
         self._created_at = created_at if created_at is not None else self._created_at
-        self._modified_at = modified_at if modified_at is not None else self._modified_at
+        self._modified_at = (
+            modified_at if modified_at is not None else self._modified_at
+        )
 
     @property
     def id(self) -> int:

bot/src/bot_data/service/achievements_repository_service.py

@@ -49,7 +49,9 @@ class AchievementRepositoryService(AchievementRepositoryABC):
 
     def get_achievements(self) -> List[Achievement]:
         achievements = List(Achievement)
-        self._logger.trace(__name__, f"Send SQL command: {Achievement.get_select_all_string()}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {Achievement.get_select_all_string()}"
+        )
         results = self._context.select(Achievement.get_select_all_string())
         for result in results:
             self._logger.trace(__name__, f"Get user with id {result[0]}")
@@ -58,7 +60,9 @@ class AchievementRepositoryService(AchievementRepositoryABC):
         return achievements
 
     def get_achievement_by_id(self, id: int) -> Achievement:
-        self._logger.trace(__name__, f"Send SQL command: {Achievement.get_select_by_id_string(id)}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {Achievement.get_select_by_id_string(id)}"
+        )
         result = self._context.select(Achievement.get_select_by_id_string(id))[0]
 
         return self._from_result(result)
@@ -69,7 +73,9 @@ class AchievementRepositoryService(AchievementRepositoryABC):
             __name__,
             f"Send SQL command: {Achievement.get_select_by_server_id_string(server_id)}",
         )
-        results = self._context.select(Achievement.get_select_by_server_id_string(server_id))
+        results = self._context.select(
+            Achievement.get_select_by_server_id_string(server_id)
+        )
         for result in results:
             self._logger.trace(__name__, f"Get user with id {result[0]}")
             achievements.append(self._from_result(result))
@@ -83,26 +89,34 @@ class AchievementRepositoryService(AchievementRepositoryABC):
             __name__,
             f"Send SQL command: {UserGotAchievement.get_select_by_user_id_string(user_id)}",
         )
-        results = self._context.select(UserGotAchievement.get_select_by_user_id_string(user_id))
+        results = self._context.select(
+            UserGotAchievement.get_select_by_user_id_string(user_id)
+        )
         for result in results:
             self._logger.trace(__name__, f"Got UserGotAchievement with id {result[0]}")
             achievements_joins.append(self._join_from_result(result))
 
         for achievements_join in achievements_joins:
-            results = self._context.select(Achievement.get_select_by_id_string(achievements_join.achievement.id))
+            results = self._context.select(
+                Achievement.get_select_by_id_string(achievements_join.achievement.id)
+            )
             for result in results:
                 self._logger.trace(__name__, f"Got Achievement with id {result[0]}")
                 achievements.append(self._from_result(result))
 
         return achievements
 
-    def get_user_got_achievements_by_achievement_id(self, achievement_id: int) -> List[Achievement]:
+    def get_user_got_achievements_by_achievement_id(
+        self, achievement_id: int
+    ) -> List[Achievement]:
         achievements_joins = List(UserGotAchievement)
         self._logger.trace(
             __name__,
             f"Send SQL command: {UserGotAchievement.get_select_by_achievement_id_string(achievement_id)}",
         )
-        results = self._context.select(UserGotAchievement.get_select_by_achievement_id_string(achievement_id))
+        results = self._context.select(
+            UserGotAchievement.get_select_by_achievement_id_string(achievement_id)
+        )
         for result in results:
             self._logger.trace(__name__, f"Got UserGotAchievement with id {result[0]}")
             achievements_joins.append(self._join_from_result(result))

bot/src/bot_data/service/api_key_repository_service.py

@@ -45,7 +45,9 @@ class ApiKeyRepositoryService(ApiKeyRepositoryABC):
 
     def get_api_keys(self) -> List[ApiKey]:
         api_keys = List(ApiKey)
-        self._logger.trace(__name__, f"Send SQL command: {ApiKey.get_select_all_string()}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {ApiKey.get_select_all_string()}"
+        )
         results = self._context.select(ApiKey.get_select_all_string())
         for result in results:
             api_keys.append(self._api_key_from_result(result))
@@ -53,16 +55,26 @@ class ApiKeyRepositoryService(ApiKeyRepositoryABC):
         return api_keys
 
     def get_api_key(self, identifier: str, key: str) -> ApiKey:
-        self._logger.trace(__name__, f"Send SQL command: {ApiKey.get_select_string(identifier, key)}")
+        self._logger.trace(
-        return self._api_key_from_result(self._context.select(ApiKey.get_select_string(identifier, key))[0])
+            __name__, f"Send SQL command: {ApiKey.get_select_string(identifier, key)}"
+        )
+        return self._api_key_from_result(
+            self._context.select(ApiKey.get_select_string(identifier, key))[0]
+        )
 
     def get_api_key_by_id(self, id: int) -> ApiKey:
         self._logger.trace(__name__, f"Send SQL command: {ApiKey.get_select_by_id(id)}")
-        return self._api_key_from_result(self._context.select(ApiKey.get_select_by_id(id))[0])
+        return self._api_key_from_result(
+            self._context.select(ApiKey.get_select_by_id(id))[0]
+        )
 
     def get_api_key_by_key(self, key: str) -> ApiKey:
-        self._logger.trace(__name__, f"Send SQL command: {ApiKey.get_select_by_key(key)}")
+        self._logger.trace(
-        return self._api_key_from_result(self._context.select(ApiKey.get_select_by_key(key))[0])
+            __name__, f"Send SQL command: {ApiKey.get_select_by_key(key)}"
+        )
+        return self._api_key_from_result(
+            self._context.select(ApiKey.get_select_by_key(key))[0]
+        )
 
     def add_api_key(self, api_key: ApiKey):
         self._logger.trace(__name__, f"Send SQL command: {api_key.insert_string}")

bot/src/bot_data/service/auth_user_repository_service.py

@@ -74,7 +74,9 @@ class AuthUserRepositoryService(AuthUserRepositoryABC):
 
     def get_all_auth_users(self) -> List[AuthUser]:
         users = List(AuthUser)
-        self._logger.trace(__name__, f"Send SQL command: {AuthUser.get_select_all_string()}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {AuthUser.get_select_all_string()}"
+        )
         results = self._context.select(AuthUser.get_select_all_string())
         for result in results:
             self._logger.trace(__name__, f"Get auth user with id {result[0]}")
@@ -82,22 +84,36 @@ class AuthUserRepositoryService(AuthUserRepositoryABC):
 
         return users
 
-    def get_filtered_auth_users(self, criteria: AuthUserSelectCriteria) -> FilteredResult:
+    def get_filtered_auth_users(
+        self, criteria: AuthUserSelectCriteria
+    ) -> FilteredResult:
         users = self.get_all_auth_users()
-        self._logger.trace(__name__, f"Send SQL command: {AuthUser.get_select_all_string()}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {AuthUser.get_select_all_string()}"
+        )
         query = users
 
         if criteria.first_name is not None and criteria.first_name != "":
-            query = query.where(lambda x: criteria.first_name in x.first_name or x.first_name == criteria.first_name)
+            query = query.where(
+                lambda x: criteria.first_name in x.first_name
+                or x.first_name == criteria.first_name
+            )
 
         if criteria.last_name is not None and criteria.last_name != "":
-            query = query.where(lambda x: criteria.last_name in x.last_name or x.last_name == criteria.last_name)
+            query = query.where(
+                lambda x: criteria.last_name in x.last_name
+                or x.last_name == criteria.last_name
+            )
 
         if criteria.email is not None and criteria.email != "":
-            query = query.where(lambda x: criteria.email in x.email or x.email == criteria.email)
+            query = query.where(
+                lambda x: criteria.email in x.email or x.email == criteria.email
+            )
 
         if criteria.auth_role is not None:
-            query = query.where(lambda x: x.auth_role == AuthRoleEnum(criteria.auth_role))
+            query = query.where(
+                lambda x: x.auth_role == AuthRoleEnum(criteria.auth_role)
+            )
 
         # sort
         if (
@@ -128,12 +144,16 @@ class AuthUserRepositoryService(AuthUserRepositoryABC):
         return result
 
     def get_auth_user_by_email(self, email: str) -> AuthUser:
-        self._logger.trace(__name__, f"Send SQL command: {AuthUser.get_select_by_email_string(email)}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {AuthUser.get_select_by_email_string(email)}"
+        )
         result = self._context.select(AuthUser.get_select_by_email_string(email))[0]
         return self._user_from_result(result)
 
     def find_auth_user_by_email(self, email: str) -> Optional[AuthUser]:
-        self._logger.trace(__name__, f"Send SQL command: {AuthUser.get_select_by_email_string(email)}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {AuthUser.get_select_by_email_string(email)}"
+        )
         result = self._context.select(AuthUser.get_select_by_email_string(email))
         if result is None or len(result) == 0:
             return None
@@ -160,7 +180,9 @@ class AuthUserRepositoryService(AuthUserRepositoryABC):
             __name__,
             f"Send SQL command: {AuthUser.get_select_by_forgot_password_id_string(id)}",
         )
-        result = self._context.select(AuthUser.get_select_by_forgot_password_id_string(id))
+        result = self._context.select(
+            AuthUser.get_select_by_forgot_password_id_string(id)
+        )
         if result is None or len(result) == 0:
             return None
 

bot/src/bot_data/service/auto_role_repository_service.py

@@ -25,7 +25,9 @@ class AutoRoleRepositoryService(AutoRoleRepositoryABC):
 
     def get_auto_roles(self) -> List[AutoRole]:
         auto_roles = List(AutoRole)
-        self._logger.trace(__name__, f"Send SQL command: {AutoRole.get_select_all_string()}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {AutoRole.get_select_all_string()}"
+        )
         results = self._context.select(AutoRole.get_select_all_string())
         for result in results:
             auto_roles.append(
@@ -42,7 +44,9 @@ class AutoRoleRepositoryService(AutoRoleRepositoryABC):
         return auto_roles
 
     def get_auto_role_by_id(self, id: int) -> AutoRole:
-        self._logger.trace(__name__, f"Send SQL command: {AutoRole.get_select_by_id_string(id)}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {AutoRole.get_select_by_id_string(id)}"
+        )
         result = self._context.select(AutoRole.get_select_by_id_string(id))[0]
         return AutoRole(
             self._servers.get_server_by_id(result[1]),
@@ -54,7 +58,9 @@ class AutoRoleRepositoryService(AutoRoleRepositoryABC):
         )
 
     def find_auto_role_by_id(self, id: int) -> Optional[AutoRole]:
-        self._logger.trace(__name__, f"Send SQL command: {AutoRole.get_select_by_id_string(id)}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {AutoRole.get_select_by_id_string(id)}"
+        )
         result = self._context.select(AutoRole.get_select_by_id_string(id))
         if result is None or len(result) == 0:
             return None
@@ -71,7 +77,9 @@ class AutoRoleRepositoryService(AutoRoleRepositoryABC):
         )
 
     def get_auto_roles_by_server_id(self, id: int) -> List[AutoRole]:
-        self._logger.trace(__name__, f"Send SQL command: {AutoRole.get_select_by_server_id_string(id)}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {AutoRole.get_select_by_server_id_string(id)}"
+        )
         auto_roles = List(AutoRole)
         results = self._context.select(AutoRole.get_select_by_server_id_string(id))
         for result in results:
@@ -137,7 +145,9 @@ class AutoRoleRepositoryService(AutoRoleRepositoryABC):
 
     def get_auto_role_rules(self) -> List[AutoRoleRule]:
         auto_role_rules = List(AutoRoleRule)
-        self._logger.trace(__name__, f"Send SQL command: {AutoRoleRule.get_select_all_string()}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {AutoRoleRule.get_select_all_string()}"
+        )
         results = self._context.select(AutoRoleRule.get_select_all_string())
         for result in results:
             auto_role_rules.append(
@@ -154,7 +164,9 @@ class AutoRoleRepositoryService(AutoRoleRepositoryABC):
         return auto_role_rules
 
     def get_auto_role_rule_by_id(self, id: int) -> AutoRoleRule:
-        self._logger.trace(__name__, f"Send SQL command: {AutoRoleRule.get_select_by_id_string(id)}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {AutoRoleRule.get_select_by_id_string(id)}"
+        )
         result = self._context.select(AutoRoleRule.get_select_by_id_string(id))[0]
         return AutoRoleRule(
             self.get_auto_role_by_id(result[1]),
@@ -171,7 +183,9 @@ class AutoRoleRepositoryService(AutoRoleRepositoryABC):
             __name__,
             f"Send SQL command: {AutoRoleRule.get_select_by_auto_role_id_string(id)}",
         )
-        results = self._context.select(AutoRoleRule.get_select_by_auto_role_id_string(id))
+        results = self._context.select(
+            AutoRoleRule.get_select_by_auto_role_id_string(id)
+        )
         for result in results:
             auto_role_rules.append(
                 AutoRoleRule(
@@ -187,13 +201,19 @@ class AutoRoleRepositoryService(AutoRoleRepositoryABC):
         return auto_role_rules
 
     def add_auto_role_rule(self, auto_role_rule: AutoRoleRule):
-        self._logger.trace(__name__, f"Send SQL command: {auto_role_rule.insert_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {auto_role_rule.insert_string}"
+        )
         self._context.cursor.execute(auto_role_rule.insert_string)
 
     def update_auto_role_rule(self, auto_role_rule: AutoRoleRule):
-        self._logger.trace(__name__, f"Send SQL command: {auto_role_rule.udpate_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {auto_role_rule.udpate_string}"
+        )
         self._context.cursor.execute(auto_role_rule.udpate_string)
 
     def delete_auto_role_rule(self, auto_role_rule: AutoRoleRule):
-        self._logger.trace(__name__, f"Send SQL command: {auto_role_rule.delete_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {auto_role_rule.delete_string}"
+        )
         self._context.cursor.execute(auto_role_rule.delete_string)

bot/src/bot_data/service/client_repository_service.py

@@ -25,7 +25,9 @@ class ClientRepositoryService(ClientRepositoryABC):
 
     def get_clients(self) -> List[Client]:
         clients = List(Client)
-        self._logger.trace(__name__, f"Send SQL command: {Client.get_select_all_string()}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {Client.get_select_all_string()}"
+        )
         results = self._context.select(Client.get_select_all_string())
         for result in results:
             self._logger.trace(__name__, f"Get client with id {result[0]}")
@@ -47,7 +49,9 @@ class ClientRepositoryService(ClientRepositoryABC):
         return clients
 
     def get_client_by_id(self, client_id: int) -> Client:
-        self._logger.trace(__name__, f"Send SQL command: {Client.get_select_by_id_string(client_id)}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {Client.get_select_by_id_string(client_id)}"
+        )
         result = self._context.select(Client.get_select_by_id_string(client_id))
         return Client(
             result[1],
@@ -92,7 +96,9 @@ class ClientRepositoryService(ClientRepositoryABC):
             __name__,
             f"Send SQL command: {Client.get_select_by_discord_id_string(discord_id)}",
         )
-        result = self._context.select(Client.get_select_by_discord_id_string(discord_id))[0]
+        result = self._context.select(
+            Client.get_select_by_discord_id_string(discord_id)
+        )[0]
         return Client(
             result[1],
             result[2],
@@ -111,7 +117,9 @@ class ClientRepositoryService(ClientRepositoryABC):
             __name__,
             f"Send SQL command: {Client.get_select_by_discord_id_string(discord_id)}",
         )
-        result = self._context.select(Client.get_select_by_discord_id_string(discord_id))
+        result = self._context.select(
+            Client.get_select_by_discord_id_string(discord_id)
+        )
         if result is None or len(result) == 0:
             return None
 
@@ -154,12 +162,16 @@ class ClientRepositoryService(ClientRepositoryABC):
             id=result[0],
         )
 
-    def find_client_by_discord_id_and_server_id(self, discord_id: int, server_id: int) -> Optional[Client]:
+    def find_client_by_discord_id_and_server_id(
+        self, discord_id: int, server_id: int
+    ) -> Optional[Client]:
         self._logger.trace(
             __name__,
             f"Send SQL command: {Client.get_select_by_discord_id_and_server_id_string(discord_id, server_id)}",
         )
-        result = self._context.select(Client.get_select_by_discord_id_and_server_id_string(discord_id, server_id))
+        result = self._context.select(
+            Client.get_select_by_discord_id_and_server_id_string(discord_id, server_id)
+        )
         if result is None or len(result) == 0:
             return None
 

bot/src/bot_data/service/game_server_repository_service.py

@@ -42,7 +42,9 @@ class GameServerRepositoryService(GameServerRepositoryABC):
         )
         results = self._context.select(GameServer.get_select_all_string())
         for result in results:
-            self._logger.trace(__name__, f"Get user-joined-game-server with id {result[0]}")
+            self._logger.trace(
+                __name__, f"Get user-joined-game-server with id {result[0]}"
+            )
             game_servers.append(self._from_result(result))
 
         return game_servers
@@ -55,7 +57,9 @@ class GameServerRepositoryService(GameServerRepositoryABC):
         )
         results = self._context.select(GameServer.get_select_by_server_id_string(id))
         for result in results:
-            self._logger.trace(__name__, f"Get user-joined-game-server with id {result[0]}")
+            self._logger.trace(
+                __name__, f"Get user-joined-game-server with id {result[0]}"
+            )
             game_servers.append(self._from_result(result))
 
         return game_servers

bot/src/bot_data/service/known_user_repository_service.py

@@ -25,7 +25,9 @@ class KnownUserRepositoryService(KnownUserRepositoryABC):
 
     def get_users(self) -> List[KnownUser]:
         users = List(KnownUser)
-        self._logger.trace(__name__, f"Send SQL command: {KnownUser.get_select_all_string()}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {KnownUser.get_select_all_string()}"
+        )
         results = self._context.select(KnownUser.get_select_all_string())
         for result in results:
             self._logger.trace(__name__, f"Get known_user with id {result[0]}")
@@ -34,7 +36,9 @@ class KnownUserRepositoryService(KnownUserRepositoryABC):
         return users
 
     def get_user_by_id(self, id: int) -> KnownUser:
-        self._logger.trace(__name__, f"Send SQL command: {KnownUser.get_select_by_id_string(id)}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {KnownUser.get_select_by_id_string(id)}"
+        )
         result = self._context.select(KnownUser.get_select_by_id_string(id))
         return KnownUser(result[1], result[2], result[3], id=result[0])
 
@@ -43,7 +47,9 @@ class KnownUserRepositoryService(KnownUserRepositoryABC):
             __name__,
             f"Send SQL command: {KnownUser.get_select_by_discord_id_string(discord_id)}",
         )
-        result = self._context.select(KnownUser.get_select_by_discord_id_string(discord_id))[0]
+        result = self._context.select(
+            KnownUser.get_select_by_discord_id_string(discord_id)
+        )[0]
         return KnownUser(result[1], result[2], result[3], id=result[0])
 
     def find_user_by_discord_id(self, discord_id: int) -> Optional[KnownUser]:
@@ -51,7 +57,9 @@ class KnownUserRepositoryService(KnownUserRepositoryABC):
             __name__,
             f"Send SQL command: {KnownUser.get_select_by_discord_id_string(discord_id)}",
         )
-        result = self._context.select(KnownUser.get_select_by_discord_id_string(discord_id))
+        result = self._context.select(
+            KnownUser.get_select_by_discord_id_string(discord_id)
+        )
         if result is None or len(result) == 0:
             return None
 

bot/src/bot_data/service/level_repository_service.py

@@ -42,7 +42,9 @@ class LevelRepositoryService(LevelRepositoryABC):
 
     def get_levels(self) -> List[Level]:
         levels = List(Level)
-        self._logger.trace(__name__, f"Send SQL command: {Level.get_select_all_string()}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {Level.get_select_all_string()}"
+        )
         results = self._context.select(Level.get_select_all_string())
         for result in results:
             self._logger.trace(__name__, f"Get level with id {result[0]}")
@@ -51,13 +53,17 @@ class LevelRepositoryService(LevelRepositoryABC):
         return levels
 
     def get_level_by_id(self, id: int) -> Level:
-        self._logger.trace(__name__, f"Send SQL command: {Level.get_select_by_id_string(id)}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {Level.get_select_by_id_string(id)}"
+        )
         result = self._context.select(Level.get_select_by_id_string(id))[0]
 
         return self._level_from_result(result)
 
     def find_level_by_id(self, id: int) -> Optional[Level]:
-        self._logger.trace(__name__, f"Send SQL command: {Level.get_select_by_id_string(id)}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {Level.get_select_by_id_string(id)}"
+        )
         result = self._context.select(Level.get_select_by_id_string(id))
         if result is None or len(result) == 0:
             return None

bot/src/bot_data/service/migration_service.py

@@ -21,7 +21,9 @@ class MigrationService:
         self._cursor = db.cursor
 
         self._migrations: List[MigrationABC] = (
-            List(type, MigrationABC.__subclasses__()).order_by(lambda x: x.name).order_by(lambda x: x.prio)
+            List(type, MigrationABC.__subclasses__())
+            .order_by(lambda x: x.name)
+            .order_by(lambda x: x.prio)
         )
 
     def migrate(self):
@@ -38,15 +40,21 @@ class MigrationService:
                         __name__,
                         f"Running SQL Command: {MigrationHistory.get_select_by_id_string(migration_id)}",
                     )
-                    migration_from_db = self._db.select(MigrationHistory.get_select_by_id_string(migration_id))
+                    migration_from_db = self._db.select(
+                        MigrationHistory.get_select_by_id_string(migration_id)
+                    )
                     if migration_from_db is not None and len(migration_from_db) > 0:
                         continue
 
                 self._logger.debug(__name__, f"Running Migration {migration_id}")
-                migration_as_service: MigrationABC = self._services.get_service(migration)
+                migration_as_service: MigrationABC = self._services.get_service(
+                    migration
+                )
                 migration_as_service.upgrade()
                 self._cursor.execute(MigrationHistory(migration_id).insert_string)
                 self._db.save_changes()
 
             except Exception as e:
-                self._logger.error(__name__, f"Cannot get migration with id {migration}", e)
+                self._logger.error(
+                    __name__, f"Cannot get migration with id {migration}", e
+                )

bot/src/bot_data/service/server_config_repository_service.py

@@ -31,9 +31,13 @@ class ServerConfigRepositoryService(ServerConfigRepositoryABC):
             __name__,
             f"Send SQL command: {ServerTeamRoleIdsConfig.get_select_by_server_id_string(server_id)}",
         )
-        results = self._context.select(ServerTeamRoleIdsConfig.get_select_by_server_id_string(server_id))
+        results = self._context.select(
+            ServerTeamRoleIdsConfig.get_select_by_server_id_string(server_id)
+        )
         for result in results:
-            self._logger.trace(__name__, f"Got ServerTeamRoleIdsConfig with id {result[0]}")
+            self._logger.trace(
+                __name__, f"Got ServerTeamRoleIdsConfig with id {result[0]}"
+            )
             ids.append(
                 ServerTeamRoleIdsConfig(
                     result[1],
@@ -53,9 +57,13 @@ class ServerConfigRepositoryService(ServerConfigRepositoryABC):
             __name__,
             f"Send SQL command: {ServerAFKChannelIdsConfig.get_select_by_server_id_string(server_id)}",
         )
-        results = self._context.select(ServerAFKChannelIdsConfig.get_select_by_server_id_string(server_id))
+        results = self._context.select(
+            ServerAFKChannelIdsConfig.get_select_by_server_id_string(server_id)
+        )
         for result in results:
-            self._logger.trace(__name__, f"Got ServerAFKChannelIdsConfig with id {result[0]}")
+            self._logger.trace(
+                __name__, f"Got ServerAFKChannelIdsConfig with id {result[0]}"
+            )
             urls.append(result[1])
 
         return urls
@@ -93,7 +101,9 @@ class ServerConfigRepositoryService(ServerConfigRepositoryABC):
             __name__,
             f"Send SQL command: {ServerConfig.get_select_by_server_id_string(server_id)}",
         )
-        result = self._context.select(ServerConfig.get_select_by_server_id_string(server_id))
+        result = self._context.select(
+            ServerConfig.get_select_by_server_id_string(server_id)
+        )
 
         return len(result) > 0
 
@@ -102,7 +112,9 @@ class ServerConfigRepositoryService(ServerConfigRepositoryABC):
             __name__,
             f"Send SQL command: {ServerConfig.get_select_by_server_id_string(server_id)}",
         )
-        result = self._context.select(ServerConfig.get_select_by_server_id_string(server_id))[0]
+        result = self._context.select(
+            ServerConfig.get_select_by_server_id_string(server_id)
+        )[0]
 
         return self._from_result(result)
 
@@ -111,7 +123,9 @@ class ServerConfigRepositoryService(ServerConfigRepositoryABC):
             __name__,
             f"Send SQL command: {ServerConfig.get_select_by_id_string(config_id)}",
         )
-        result = self._context.select(ServerConfig.get_select_by_id_string(config_id))[0]
+        result = self._context.select(ServerConfig.get_select_by_id_string(config_id))[
+            0
+        ]
 
         return self._from_result(result)
 
@@ -127,26 +141,50 @@ class ServerConfigRepositoryService(ServerConfigRepositoryABC):
         self._logger.trace(__name__, f"Send SQL command: {server_config.delete_string}")
         self._context.cursor.execute(server_config.delete_string)
 
-    def add_server_team_role_id_config(self, server_team_role_id: ServerTeamRoleIdsConfig):
+    def add_server_team_role_id_config(
-        self._logger.trace(__name__, f"Send SQL command: {server_team_role_id.insert_string}")
+        self, server_team_role_id: ServerTeamRoleIdsConfig
+    ):
+        self._logger.trace(
+            __name__, f"Send SQL command: {server_team_role_id.insert_string}"
+        )
         self._context.cursor.execute(server_team_role_id.insert_string)
 
-    def update_server_team_role_id_config(self, server_team_role_id: ServerTeamRoleIdsConfig):
+    def update_server_team_role_id_config(
-        self._logger.trace(__name__, f"Send SQL command: {server_team_role_id.udpate_string}")
+        self, server_team_role_id: ServerTeamRoleIdsConfig
+    ):
+        self._logger.trace(
+            __name__, f"Send SQL command: {server_team_role_id.udpate_string}"
+        )
         self._context.cursor.execute(server_team_role_id.udpate_string)
 
-    def delete_server_team_role_id_config(self, server_team_role_id: ServerTeamRoleIdsConfig):
+    def delete_server_team_role_id_config(
-        self._logger.trace(__name__, f"Send SQL command: {server_team_role_id.delete_string}")
+        self, server_team_role_id: ServerTeamRoleIdsConfig
+    ):
+        self._logger.trace(
+            __name__, f"Send SQL command: {server_team_role_id.delete_string}"
+        )
         self._context.cursor.execute(server_team_role_id.delete_string)
 
-    def add_server_afk_channel_config(self, server_afk_channel: ServerAFKChannelIdsConfig):
+    def add_server_afk_channel_config(
-        self._logger.trace(__name__, f"Send SQL command: {server_afk_channel.insert_string}")
+        self, server_afk_channel: ServerAFKChannelIdsConfig
+    ):
+        self._logger.trace(
+            __name__, f"Send SQL command: {server_afk_channel.insert_string}"
+        )
         self._context.cursor.execute(server_afk_channel.insert_string)
 
-    def update_server_afk_channel_config(self, server_afk_channel: ServerAFKChannelIdsConfig):
+    def update_server_afk_channel_config(
-        self._logger.trace(__name__, f"Send SQL command: {server_afk_channel.udpate_string}")
+        self, server_afk_channel: ServerAFKChannelIdsConfig
+    ):
+        self._logger.trace(
+            __name__, f"Send SQL command: {server_afk_channel.udpate_string}"
+        )
         self._context.cursor.execute(server_afk_channel.udpate_string)
 
-    def delete_server_afk_channel_config(self, server_afk_channel: ServerAFKChannelIdsConfig):
+    def delete_server_afk_channel_config(
-        self._logger.trace(__name__, f"Send SQL command: {server_afk_channel.delete_string}")
+        self, server_afk_channel: ServerAFKChannelIdsConfig
+    ):
+        self._logger.trace(
+            __name__, f"Send SQL command: {server_afk_channel.delete_string}"
+        )
         self._context.cursor.execute(server_afk_channel.delete_string)

bot/src/bot_data/service/server_repository_service.py

@@ -26,7 +26,9 @@ class ServerRepositoryService(ServerRepositoryABC):
 
     def get_servers(self) -> List[Server]:
         servers = List(Server)
-        self._logger.trace(__name__, f"Send SQL command: {Server.get_select_all_string()}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {Server.get_select_all_string()}"
+        )
         results = self._context.select(Server.get_select_all_string())
         for result in results:
             servers.append(Server(result[1], result[2], result[3], id=result[0]))
@@ -36,7 +38,9 @@ class ServerRepositoryService(ServerRepositoryABC):
 
     def get_filtered_servers(self, criteria: ServerSelectCriteria) -> FilteredResult:
         servers = self.get_servers()
-        self._logger.trace(__name__, f"Send SQL command: {Server.get_select_all_string()}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {Server.get_select_all_string()}"
+        )
         query = servers
 
         # sort
@@ -48,7 +52,9 @@ class ServerRepositoryService(ServerRepositoryABC):
         ):
             crit_sort_direction = criteria.sort_direction.lower()
             if crit_sort_direction == "desc" or crit_sort_direction == "descending":
-                query = query.order_by_descending(lambda x: getattr(x, criteria.sort_column))
+                query = query.order_by_descending(
+                    lambda x: getattr(x, criteria.sort_column)
+                )
             else:
                 query = query.order_by(lambda x: getattr(x, criteria.sort_column))
 
@@ -60,19 +66,25 @@ class ServerRepositoryService(ServerRepositoryABC):
         return result
 
     def get_server_by_id(self, server_id: int) -> Server:
-        cs = self._cache.cached_server.where(lambda x: x.id == server_id).single_or_default()
+        cs = self._cache.cached_server.where(
+            lambda x: x.id == server_id
+        ).single_or_default()
 
         if cs is not None:
             return cs
 
-        self._logger.trace(__name__, f"Send SQL command: {Server.get_select_by_id_string(server_id)}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {Server.get_select_by_id_string(server_id)}"
+        )
         result = self._context.select(Server.get_select_by_id_string(server_id))[0]
         server = Server(result[1], result[2], result[3], id=result[0])
         self._cache.add_server(server)
         return server
 
     def get_server_by_discord_id(self, discord_id: int) -> Server:
-        cs = self._cache.cached_server.where(lambda x: x.discord_id == discord_id).single_or_default()
+        cs = self._cache.cached_server.where(
+            lambda x: x.discord_id == discord_id
+        ).single_or_default()
         if cs is not None:
             return cs
 
@@ -80,11 +92,15 @@ class ServerRepositoryService(ServerRepositoryABC):
             __name__,
             f"Send SQL command: {Server.get_select_by_discord_id_string(discord_id)}",
         )
-        result = self._context.select(Server.get_select_by_discord_id_string(discord_id))[0]
+        result = self._context.select(
+            Server.get_select_by_discord_id_string(discord_id)
+        )[0]
         return Server(result[1], result[2], result[3], id=result[0])
 
     def find_server_by_discord_id(self, discord_id: int) -> Optional[Server]:
-        cs = self._cache.cached_server.where(lambda x: x.discord_id == discord_id).single_or_default()
+        cs = self._cache.cached_server.where(
+            lambda x: x.discord_id == discord_id
+        ).single_or_default()
         if cs is not None:
             return cs
 
@@ -92,7 +108,9 @@ class ServerRepositoryService(ServerRepositoryABC):
             __name__,
             f"Send SQL command: {Server.get_select_by_discord_id_string(discord_id)}",
         )
-        result = self._context.select(Server.get_select_by_discord_id_string(discord_id))
+        result = self._context.select(
+            Server.get_select_by_discord_id_string(discord_id)
+        )
         if result is None or len(result) == 0:
             return None
 

bot/src/bot_data/service/short_role_name_repository_service.py

@@ -35,7 +35,9 @@ class ShortRoleNameRepositoryService(ShortRoleNameRepositoryABC):
         return ShortRoleName(
             self._get_value_from_result(sql_result[1]),  # name
             int(self._get_value_from_result(sql_result[2])),  # role_id
-            ShortRoleNamePositionEnum(self._get_value_from_result(sql_result[3])),  # position
+            ShortRoleNamePositionEnum(
+                self._get_value_from_result(sql_result[3])
+            ),  # position
             self._servers.get_server_by_id(sql_result[4]),  # server
             self._get_value_from_result(sql_result[5]),  # created_at
             self._get_value_from_result(sql_result[6]),  # modified_at
@@ -44,7 +46,9 @@ class ShortRoleNameRepositoryService(ShortRoleNameRepositoryABC):
 
     def get_short_role_names(self) -> List[ShortRoleName]:
         short_role_names = List(ShortRoleName)
-        self._logger.trace(__name__, f"Send SQL command: {ShortRoleName.get_select_all_string()}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {ShortRoleName.get_select_all_string()}"
+        )
         results = self._context.select(ShortRoleName.get_select_all_string())
         for result in results:
             self._logger.trace(__name__, f"Get short_role_name with id {result[0]}")
@@ -53,7 +57,9 @@ class ShortRoleNameRepositoryService(ShortRoleNameRepositoryABC):
         return short_role_names
 
     def get_short_role_name_by_id(self, id: int) -> ShortRoleName:
-        self._logger.trace(__name__, f"Send SQL command: {ShortRoleName.get_select_by_id_string(id)}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {ShortRoleName.get_select_by_id_string(id)}"
+        )
         result = self._context.select(ShortRoleName.get_select_by_id_string(id))[0]
 
         return self._short_role_name_from_result(result)
@@ -64,7 +70,9 @@ class ShortRoleNameRepositoryService(ShortRoleNameRepositoryABC):
             __name__,
             f"Send SQL command: {ShortRoleName.get_select_by_role_id_string(role_id)}",
         )
-        results = self._context.select(ShortRoleName.get_select_by_role_id_string(role_id))
+        results = self._context.select(
+            ShortRoleName.get_select_by_role_id_string(role_id)
+        )
         for result in results:
             self._logger.trace(__name__, f"Get short_role_name with id {result[0]}")
             short_role_names.append(self._short_role_name_from_result(result))
@@ -77,7 +85,9 @@ class ShortRoleNameRepositoryService(ShortRoleNameRepositoryABC):
             __name__,
             f"Send SQL command: {ShortRoleName.get_select_by_server_id_string(server_id)}",
         )
-        results = self._context.select(ShortRoleName.get_select_by_server_id_string(server_id))
+        results = self._context.select(
+            ShortRoleName.get_select_by_server_id_string(server_id)
+        )
 
         for result in results:
             self._logger.trace(__name__, f"Get short_role_name with id {result[0]}")
@@ -86,13 +96,19 @@ class ShortRoleNameRepositoryService(ShortRoleNameRepositoryABC):
         return short_role_names
 
     def add_short_role_name(self, short_role_name: ShortRoleName):
-        self._logger.trace(__name__, f"Send SQL command: {short_role_name.insert_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {short_role_name.insert_string}"
+        )
         self._context.cursor.execute(short_role_name.insert_string)
 
     def update_short_role_name(self, short_role_name: ShortRoleName):
-        self._logger.trace(__name__, f"Send SQL command: {short_role_name.udpate_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {short_role_name.udpate_string}"
+        )
         self._context.cursor.execute(short_role_name.udpate_string)
 
     def delete_short_role_name(self, short_role_name: ShortRoleName):
-        self._logger.trace(__name__, f"Send SQL command: {short_role_name.delete_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {short_role_name.delete_string}"
+        )
         self._context.cursor.execute(short_role_name.delete_string)

bot/src/bot_data/service/steam_special_offer_repository_service.py

@@ -43,7 +43,9 @@ class SteamSpecialOfferRepositoryService(SteamSpecialOfferRepositoryABC):
 
     def get_steam_special_offers(self) -> List[SteamSpecialOffer]:
         steam_special_offers = List(SteamSpecialOffer)
-        self._logger.trace(__name__, f"Send SQL command: {SteamSpecialOffer.get_select_all_string()}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {SteamSpecialOffer.get_select_all_string()}"
+        )
         results = self._context.select(SteamSpecialOffer.get_select_all_string())
         for result in results:
             self._logger.trace(__name__, f"Get steam_special_offer with id {result[0]}")
@@ -56,18 +58,26 @@ class SteamSpecialOfferRepositoryService(SteamSpecialOfferRepositoryABC):
             __name__,
             f"Send SQL command: {SteamSpecialOffer.get_select_by_name_string(name)}",
         )
-        result = self._context.select(SteamSpecialOffer.get_select_by_name_string(name))[0]
+        result = self._context.select(
+            SteamSpecialOffer.get_select_by_name_string(name)
+        )[0]
 
         return self._steam_special_offer_from_result(result)
 
     def add_steam_special_offer(self, steam_special_offer: SteamSpecialOffer):
-        self._logger.trace(__name__, f"Send SQL command: {steam_special_offer.insert_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {steam_special_offer.insert_string}"
+        )
         self._context.cursor.execute(steam_special_offer.insert_string)
 
     def update_steam_special_offer(self, steam_special_offer: SteamSpecialOffer):
-        self._logger.trace(__name__, f"Send SQL command: {steam_special_offer.udpate_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {steam_special_offer.udpate_string}"
+        )
         self._context.cursor.execute(steam_special_offer.udpate_string)
 
     def delete_steam_special_offer(self, steam_special_offer: SteamSpecialOffer):
-        self._logger.trace(__name__, f"Send SQL command: {steam_special_offer.delete_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {steam_special_offer.delete_string}"
+        )
         self._context.cursor.execute(steam_special_offer.delete_string)

bot/src/bot_data/service/technician_config_repository_service.py

@@ -19,7 +19,9 @@ class TechnicianConfigRepositoryService(TechnicianConfigRepositoryABC):
 
     def _get_technician_ids(self) -> List[int]:
         ids = List(int)
-        self._logger.trace(__name__, f"Send SQL command: {TechnicianIdConfig.get_select_all_string()}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {TechnicianIdConfig.get_select_all_string()}"
+        )
         results = self._context.select(TechnicianIdConfig.get_select_all_string())
         for result in results:
             self._logger.trace(__name__, f"Got TechnicianId with id {result[0]}")
@@ -55,27 +57,37 @@ class TechnicianConfigRepositoryService(TechnicianConfigRepositoryABC):
         )
 
     def does_technician_config_exists(self) -> bool:
-        self._logger.trace(__name__, f"Send SQL command: {TechnicianConfig.get_select_all_string()}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {TechnicianConfig.get_select_all_string()}"
+        )
         result = self._context.select(TechnicianConfig.get_select_all_string())
 
         return len(result) > 0
 
     def get_technician_config(self) -> TechnicianConfig:
-        self._logger.trace(__name__, f"Send SQL command: {TechnicianConfig.get_select_all_string()}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {TechnicianConfig.get_select_all_string()}"
+        )
         result = self._context.select(TechnicianConfig.get_select_all_string())[0]
 
         return self._from_result(result)
 
     def add_technician_config(self, technician_config: TechnicianConfig):
-        self._logger.trace(__name__, f"Send SQL command: {technician_config.insert_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {technician_config.insert_string}"
+        )
         self._context.cursor.execute(technician_config.insert_string)
 
     def update_technician_config(self, technician_config: TechnicianConfig):
-        self._logger.trace(__name__, f"Send SQL command: {technician_config.udpate_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {technician_config.udpate_string}"
+        )
         self._context.cursor.execute(technician_config.udpate_string)
 
     def delete_technician_config(self, technician_config: TechnicianConfig):
-        self._logger.trace(__name__, f"Send SQL command: {technician_config.delete_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {technician_config.delete_string}"
+        )
         self._context.cursor.execute(technician_config.delete_string)
 
     def add_technician_id_config(self, technician_id: TechnicianIdConfig):
@@ -90,14 +102,26 @@ class TechnicianConfigRepositoryService(TechnicianConfigRepositoryABC):
         self._logger.trace(__name__, f"Send SQL command: {technician_id.delete_string}")
         self._context.cursor.execute(technician_id.delete_string)
 
-    def add_technician_ping_url_config(self, technician_ping_url: TechnicianPingUrlConfig):
+    def add_technician_ping_url_config(
-        self._logger.trace(__name__, f"Send SQL command: {technician_ping_url.insert_string}")
+        self, technician_ping_url: TechnicianPingUrlConfig
+    ):
+        self._logger.trace(
+            __name__, f"Send SQL command: {technician_ping_url.insert_string}"
+        )
         self._context.cursor.execute(technician_ping_url.insert_string)
 
-    def update_technician_ping_url_config(self, technician_ping_url: TechnicianPingUrlConfig):
+    def update_technician_ping_url_config(
-        self._logger.trace(__name__, f"Send SQL command: {technician_ping_url.udpate_string}")
+        self, technician_ping_url: TechnicianPingUrlConfig
+    ):
+        self._logger.trace(
+            __name__, f"Send SQL command: {technician_ping_url.udpate_string}"
+        )
         self._context.cursor.execute(technician_ping_url.udpate_string)
 
-    def delete_technician_ping_url_config(self, technician_ping_url: TechnicianPingUrlConfig):
+    def delete_technician_ping_url_config(
-        self._logger.trace(__name__, f"Send SQL command: {technician_ping_url.delete_string}")
+        self, technician_ping_url: TechnicianPingUrlConfig
+    ):
+        self._logger.trace(
+            __name__, f"Send SQL command: {technician_ping_url.delete_string}"
+        )
         self._context.cursor.execute(technician_ping_url.delete_string)

bot/src/bot_data/service/technician_config_seeder.py

@@ -42,10 +42,14 @@ class TechnicianConfigSeeder(DataSeederABC):
 
             self._technician_config.add_technician_config(config)
             for technician in config.technician_ids:
-                self._technician_config.add_technician_id_config(TechnicianIdConfig(technician))
+                self._technician_config.add_technician_id_config(
+                    TechnicianIdConfig(technician)
+                )
 
             for url in config.ping_urls:
-                self._technician_config.add_technician_ping_url_config(TechnicianPingUrlConfig(url))
+                self._technician_config.add_technician_ping_url_config(
+                    TechnicianPingUrlConfig(url)
+                )
 
             self._db.save_changes()
             self._logger.debug(__name__, "Seeded technician config")

bot/src/bot_data/service/user_game_ident_repository_service.py

@@ -51,13 +51,17 @@ class UserGameIdentRepositoryService(UserGameIdentRepositoryABC):
 
         return joins
 
-    def get_user_game_idents_by_game_server_id(self, game_server_id: int) -> List[UserGameIdent]:
+    def get_user_game_idents_by_game_server_id(
+        self, game_server_id: int
+    ) -> List[UserGameIdent]:
         joins = List(UserGameIdent)
         self._logger.trace(
             __name__,
             f"Send SQL command: {UserGameIdent.get_select_by_game_server_id_string(game_server_id)}",
         )
-        results = self._context.select(UserGameIdent.get_select_by_game_server_id_string(game_server_id))
+        results = self._context.select(
+            UserGameIdent.get_select_by_game_server_id_string(game_server_id)
+        )
         for result in results:
             self._logger.trace(__name__, f"Get UserGameIdent with id {result[0]}")
             joins.append(self._from_result(result))
@@ -77,7 +81,9 @@ class UserGameIdentRepositoryService(UserGameIdentRepositoryABC):
             __name__,
             f"Send SQL command: {UserGameIdent.get_select_by_ident_string(ident)}",
         )
-        result = self._context.select(UserGameIdent.get_select_by_ident_string(ident))[0]
+        result = self._context.select(UserGameIdent.get_select_by_ident_string(ident))[
+            0
+        ]
         return self._from_result(result)
 
     def find_user_game_ident_by_ident(self, ident: str) -> Optional[UserGameIdent]:
@@ -98,22 +104,30 @@ class UserGameIdentRepositoryService(UserGameIdentRepositoryABC):
             __name__,
             f"Send SQL command: {UserGameIdent.get_select_by_user_id_string(user_id)}",
         )
-        results = self._context.select(UserGameIdent.get_select_by_user_id_string(user_id))
+        results = self._context.select(
+            UserGameIdent.get_select_by_user_id_string(user_id)
+        )
         for result in results:
             joins.append(self._from_result(result))
 
         return joins
 
     def add_user_game_ident(self, user_game_ident: UserGameIdent):
-        self._logger.trace(__name__, f"Send SQL command: {user_game_ident.insert_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {user_game_ident.insert_string}"
+        )
         self._context.cursor.execute(user_game_ident.insert_string)
 
     def update_user_game_ident(self, user_game_ident: UserGameIdent):
-        self._logger.trace(__name__, f"Send SQL command: {user_game_ident.udpate_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {user_game_ident.udpate_string}"
+        )
         self._context.cursor.execute(user_game_ident.udpate_string)
 
     def delete_user_game_ident(self, user_game_ident: UserGameIdent):
-        self._logger.trace(__name__, f"Send SQL command: {user_game_ident.delete_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {user_game_ident.delete_string}"
+        )
         self._context.cursor.execute(user_game_ident.delete_string)
 
     def delete_user_game_ident_by_user_id(self, user_id: int):

bot/src/bot_data/service/user_joined_game_server_repository_service.py

@@ -46,7 +46,9 @@ class UserJoinedGameServerRepositoryService(UserJoinedGameServerRepositoryABC):
         )
         results = self._context.select(UserJoinedGameServer.get_select_all_string())
         for result in results:
-            self._logger.trace(__name__, f"Get user-joined-game-server with id {result[0]}")
+            self._logger.trace(
+                __name__, f"Get user-joined-game-server with id {result[0]}"
+            )
             joins.append(self._from_result(result))
 
         return joins
@@ -56,35 +58,49 @@ class UserJoinedGameServerRepositoryService(UserJoinedGameServerRepositoryABC):
             __name__,
             f"Send SQL command: {UserJoinedGameServer.get_select_by_id_string(id)}",
         )
-        result = self._context.select(UserJoinedGameServer.get_select_by_id_string(id))[0]
+        result = self._context.select(UserJoinedGameServer.get_select_by_id_string(id))[
+            0
+        ]
         return self._from_result(result)
 
-    def get_user_joined_game_servers_by_user_id(self, user_id: int) -> List[UserJoinedGameServer]:
+    def get_user_joined_game_servers_by_user_id(
+        self, user_id: int
+    ) -> List[UserJoinedGameServer]:
         joins = List(UserJoinedGameServer)
         self._logger.trace(
             __name__,
             f"Send SQL command: {UserJoinedGameServer.get_select_by_user_id_string(user_id)}",
         )
-        results = self._context.select(UserJoinedGameServer.get_select_by_user_id_string(user_id))
+        results = self._context.select(
+            UserJoinedGameServer.get_select_by_user_id_string(user_id)
+        )
         for result in results:
             joins.append(self._from_result(result))
 
         return joins
 
-    def get_active_user_joined_game_server_by_user_id(self, user_id: int) -> UserJoinedGameServer:
+    def get_active_user_joined_game_server_by_user_id(
+        self, user_id: int
+    ) -> UserJoinedGameServer:
         self._logger.trace(
             __name__,
             f"Send SQL command: {UserJoinedGameServer.get_select_by_user_id_string(user_id)}",
         )
-        result = self._context.select(UserJoinedGameServer.get_select_active_by_user_id_string(user_id))[0]
+        result = self._context.select(
+            UserJoinedGameServer.get_select_active_by_user_id_string(user_id)
+        )[0]
         return self._from_result(result)
 
-    def find_active_user_joined_game_server_by_user_id(self, user_id: int) -> Optional[UserJoinedGameServer]:
+    def find_active_user_joined_game_server_by_user_id(
+        self, user_id: int
+    ) -> Optional[UserJoinedGameServer]:
         self._logger.trace(
             __name__,
             f"Send SQL command: {UserJoinedGameServer.get_select_by_user_id_string(user_id)}",
         )
-        result = self._context.select(UserJoinedGameServer.get_select_active_by_user_id_string(user_id))
+        result = self._context.select(
+            UserJoinedGameServer.get_select_active_by_user_id_string(user_id)
+        )
         if result is None or len(result) == 0:
             return None
 
@@ -92,29 +108,45 @@ class UserJoinedGameServerRepositoryService(UserJoinedGameServerRepositoryABC):
 
         return self._from_result(result)
 
-    def find_active_user_joined_game_servers_by_user_id(self, user_id: int) -> List[Optional[UserJoinedGameServer]]:
+    def find_active_user_joined_game_servers_by_user_id(
+        self, user_id: int
+    ) -> List[Optional[UserJoinedGameServer]]:
         self._logger.trace(
             __name__,
             f"Send SQL command: {UserJoinedGameServer.get_select_active_by_user_id_string(user_id)}",
         )
         result = List(UserJoinedGameServer)
-        db_results = self._context.select(UserJoinedGameServer.get_select_active_by_user_id_string(user_id))
+        db_results = self._context.select(
+            UserJoinedGameServer.get_select_active_by_user_id_string(user_id)
+        )
 
         for db_result in db_results:
             result.append(self._from_result(db_result))
 
         return result
 
-    def add_user_joined_game_server(self, user_joined_game_server: UserJoinedGameServer):
+    def add_user_joined_game_server(
-        self._logger.trace(__name__, f"Send SQL command: {user_joined_game_server.insert_string}")
+        self, user_joined_game_server: UserJoinedGameServer
+    ):
+        self._logger.trace(
+            __name__, f"Send SQL command: {user_joined_game_server.insert_string}"
+        )
         self._context.cursor.execute(user_joined_game_server.insert_string)
 
-    def update_user_joined_game_server(self, user_joined_game_server: UserJoinedGameServer):
+    def update_user_joined_game_server(
-        self._logger.trace(__name__, f"Send SQL command: {user_joined_game_server.udpate_string}")
+        self, user_joined_game_server: UserJoinedGameServer
+    ):
+        self._logger.trace(
+            __name__, f"Send SQL command: {user_joined_game_server.udpate_string}"
+        )
         self._context.cursor.execute(user_joined_game_server.udpate_string)
 
-    def delete_user_joined_game_server(self, user_joined_game_server: UserJoinedGameServer):
+    def delete_user_joined_game_server(
-        self._logger.trace(__name__, f"Send SQL command: {user_joined_game_server.delete_string}")
+        self, user_joined_game_server: UserJoinedGameServer
+    ):
+        self._logger.trace(
+            __name__, f"Send SQL command: {user_joined_game_server.delete_string}"
+        )
         self._context.cursor.execute(user_joined_game_server.delete_string)
 
     def delete_user_joined_game_server_by_user_id(self, user_id: int):
@@ -122,4 +154,6 @@ class UserJoinedGameServerRepositoryService(UserJoinedGameServerRepositoryABC):
             __name__,
             f"Send SQL command: {UserJoinedGameServer.delete_by_user_id_string}",
         )
-        self._context.cursor.execute(UserJoinedGameServer.delete_by_user_id_string(user_id))
+        self._context.cursor.execute(
+            UserJoinedGameServer.delete_by_user_id_string(user_id)
+        )

bot/src/bot_data/service/user_joined_server_repository_service.py

@@ -25,7 +25,9 @@ class UserJoinedServerRepositoryService(UserJoinedServerRepositoryABC):
 
     def get_user_joined_servers(self) -> List[UserJoinedServer]:
         joins = List(UserJoinedServer)
-        self._logger.trace(__name__, f"Send SQL command: {UserJoinedServer.get_select_all_string()}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {UserJoinedServer.get_select_all_string()}"
+        )
         results = self._context.select(UserJoinedServer.get_select_all_string())
         for result in results:
             self._logger.trace(__name__, f"Get user-joined-server with id {result[0]}")
@@ -72,13 +74,17 @@ class UserJoinedServerRepositoryService(UserJoinedServerRepositoryABC):
             id=result[0],
         )
 
-    def get_user_joined_servers_by_user_id(self, user_id: int) -> List[UserJoinedServer]:
+    def get_user_joined_servers_by_user_id(
+        self, user_id: int
+    ) -> List[UserJoinedServer]:
         joins = List(UserJoinedServer)
         self._logger.trace(
             __name__,
             f"Send SQL command: {UserJoinedServer.get_select_by_user_id_string(user_id)}",
         )
-        results = self._context.select(UserJoinedServer.get_select_by_user_id_string(user_id))
+        results = self._context.select(
+            UserJoinedServer.get_select_by_user_id_string(user_id)
+        )
         for result in results:
             joins.append(
                 UserJoinedServer(
@@ -93,12 +99,16 @@ class UserJoinedServerRepositoryService(UserJoinedServerRepositoryABC):
 
         return joins
 
-    def get_active_user_joined_server_by_user_id(self, user_id: int) -> UserJoinedServer:
+    def get_active_user_joined_server_by_user_id(
+        self, user_id: int
+    ) -> UserJoinedServer:
         self._logger.trace(
             __name__,
             f"Send SQL command: {UserJoinedServer.get_select_by_user_id_string(user_id)}",
         )
-        result = self._context.select(UserJoinedServer.get_select_active_by_user_id_string(user_id))[0]
+        result = self._context.select(
+            UserJoinedServer.get_select_active_by_user_id_string(user_id)
+        )[0]
         return UserJoinedServer(
             self._users.get_user_by_id(result[1]),
             result[2],
@@ -108,12 +118,16 @@ class UserJoinedServerRepositoryService(UserJoinedServerRepositoryABC):
             id=result[0],
         )
 
-    def find_active_user_joined_server_by_user_id(self, user_id: int) -> Optional[UserJoinedServer]:
+    def find_active_user_joined_server_by_user_id(
+        self, user_id: int
+    ) -> Optional[UserJoinedServer]:
         self._logger.trace(
             __name__,
             f"Send SQL command: {UserJoinedServer.get_select_by_user_id_string(user_id)}",
         )
-        result = self._context.select(UserJoinedServer.get_select_active_by_user_id_string(user_id))
+        result = self._context.select(
+            UserJoinedServer.get_select_active_by_user_id_string(user_id)
+        )
         if result is None or len(result) == 0:
             return None
 
@@ -129,13 +143,19 @@ class UserJoinedServerRepositoryService(UserJoinedServerRepositoryABC):
         )
 
     def add_user_joined_server(self, user_joined_server: UserJoinedServer):
-        self._logger.trace(__name__, f"Send SQL command: {user_joined_server.insert_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {user_joined_server.insert_string}"
+        )
         self._context.cursor.execute(user_joined_server.insert_string)
 
     def update_user_joined_server(self, user_joined_server: UserJoinedServer):
-        self._logger.trace(__name__, f"Send SQL command: {user_joined_server.udpate_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {user_joined_server.udpate_string}"
+        )
         self._context.cursor.execute(user_joined_server.udpate_string)
 
     def delete_user_joined_server(self, user_joined_server: UserJoinedServer):
-        self._logger.trace(__name__, f"Send SQL command: {user_joined_server.delete_string}")
+        self._logger.trace(
+            __name__, f"Send SQL command: {user_joined_server.delete_string}"
+        )
         self._context.cursor.execute(user_joined_server.delete_string)