Changed config loading from file to db #127

kdb-bot/src/bot_data/abc/server_config_repository_abc.py

@@ -0,0 +1,55 @@
+from abc import ABC, abstractmethod
+
+from bot_data.model.server_afk_channel_ids_config import ServerAFKChannelIdsConfig
+from bot_data.model.server_config import ServerConfig
+from bot_data.model.server_team_role_ids_config import ServerTeamRoleIdsConfig
+
+
+class ServerConfigRepositoryABC(ABC):
+    @abstractmethod
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def does_server_config_exists(self, server_id: int) -> bool:
+        pass
+
+    @abstractmethod
+    def get_server_config(self, server_id: int) -> ServerConfig:
+        pass
+
+    @abstractmethod
+    def add_server_config(self, server_config: ServerConfig):
+        pass
+
+    @abstractmethod
+    def update_server_config(self, server_config: ServerConfig):
+        pass
+
+    @abstractmethod
+    def delete_server_config(self, server_config: ServerConfig):
+        pass
+
+    @abstractmethod
+    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):
+        pass
+
+    @abstractmethod
+    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):
+        pass
+
+    @abstractmethod
+    def update_server_afk_channel_config(self, server_afk_channel: ServerAFKChannelIdsConfig):
+        pass
+
+    @abstractmethod
+    def delete_server_afk_channel_config(self, server_afk_channel: ServerAFKChannelIdsConfig):
+        pass

kdb-bot/src/bot_data/data_module.py

@@ -14,6 +14,7 @@ from bot_data.abc.data_seeder_abc import DataSeederABC
 from bot_data.abc.game_server_repository_abc import GameServerRepositoryABC
 from bot_data.abc.known_user_repository_abc import KnownUserRepositoryABC
 from bot_data.abc.level_repository_abc import LevelRepositoryABC
+from bot_data.abc.server_config_repository_abc import ServerConfigRepositoryABC
 from bot_data.abc.server_repository_abc import ServerRepositoryABC
 from bot_data.abc.technician_config_repository_abc import TechnicianConfigRepositoryABC
 from bot_data.abc.user_game_ident_repository_abc import UserGameIdentRepositoryABC
@@ -37,6 +38,8 @@ from bot_data.service.game_server_repository_service import GameServerRepository
 from bot_data.service.known_user_repository_service import KnownUserRepositoryService
 from bot_data.service.level_repository_service import LevelRepositoryService
 from bot_data.service.seeder_service import SeederService
+from bot_data.service.server_config_repository_service import ServerConfigRepositoryService
+from bot_data.service.server_config_seeder import ServerConfigSeeder
 from bot_data.service.server_repository_service import ServerRepositoryService
 from bot_data.service.technician_config_repository_service import TechnicianConfigRepositoryService
 from bot_data.service.technician_config_seeder import TechnicianConfigSeeder
@@ -85,6 +88,8 @@ class DataModule(ModuleABC):
         services.add_transient(UserGameIdentRepositoryABC, UserGameIdentRepositoryService)
         services.add_transient(AchievementRepositoryABC, AchievementRepositoryService)
         services.add_transient(TechnicianConfigRepositoryABC, TechnicianConfigRepositoryService)
+        services.add_transient(ServerConfigRepositoryABC, ServerConfigRepositoryService)
 
         services.add_transient(SeederService)
         services.add_transient(DataSeederABC, TechnicianConfigSeeder)
+        services.add_transient(DataSeederABC, ServerConfigSeeder)

kdb-bot/src/bot_data/model/server_afk_channel_ids_config.py

@@ -0,0 +1,76 @@
+from datetime import datetime
+
+from cpl_core.database import TableABC
+
+
+class ServerAFKChannelIdsConfig(TableABC):
+    def __init__(
+        self,
+        channel_id: int,
+        server_id: int,
+        created_at: datetime = None,
+        modified_at: datetime = None,
+        id=0,
+    ):
+        self._id = id
+        self._channel_id = channel_id
+        self._server_id = server_id
+
+        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
+
+    @property
+    def channel_id(self) -> int:
+        return self._channel_id
+
+    @staticmethod
+    def get_select_all_string() -> str:
+        return str(
+            f"""
+                SELECT * FROM `CFG_ServerAFKChannelIds`;
+            """
+        )
+
+    @staticmethod
+    def get_select_by_id_string(id: int) -> str:
+        return str(
+            f"""
+                SELECT * FROM `CFG_ServerAFKChannelIds`
+                WHERE `Id` = {id};
+            """
+        )
+
+    @property
+    def insert_string(self) -> str:
+        return str(
+            f"""
+                INSERT INTO `CFG_ServerAFKChannelIds` (
+                    `RoleId`,
+                    `ServerId`
+                ) VALUES (
+                    {self._channel_id},
+                    {self._server_id}
+                );
+            """
+        )
+
+    @property
+    def udpate_string(self) -> str:
+        return str(
+            f"""
+                UPDATE `CFG_ServerAFKChannelIds`
+                SET `RoleId` = {self._channel_id},
+                `ServerId` = {self._server_id}
+                WHERE `Id` = {self._id};
+            """
+        )
+
+    @property
+    def delete_string(self) -> str:
+        return str(
+            f"""
+                DELETE FROM `CFG_ServerAFKChannelIds`
+                WHERE `Id` = {self._id};
+            """
+        )

kdb-bot/src/bot_data/model/server_config.py

@@ -0,0 +1,205 @@
+from datetime import datetime
+
+from cpl_core.configuration import ConfigurationModelABC
+from cpl_core.database import TableABC
+from cpl_query.extension import List
+
+from bot_data.model.server import Server
+from bot_data.model.server_team_role_ids_config import ServerTeamRoleIdsConfig
+
+
+class ServerConfig(TableABC, ConfigurationModelABC):
+    def __init__(
+        self,
+        message_delete_timer: int,
+        notification_chat_id: int,
+        max_voice_state_hours: int,
+        xp_per_message: int,
+        xp_per_reaction: int,
+        max_message_xp_per_hour: int,
+        xp_per_ontime_hour: int,
+        xp_per_event_participation: int,
+        xp_per_achievement: int,
+        afk_command_channel_id: int,
+        help_voice_channel_id: int,
+        team_channel_id: int,
+        login_message_channel_id: int,
+        server: Server,
+        afk_channel_ids: List[int],
+        team_role_ids: List[ServerTeamRoleIdsConfig],
+        created_at: datetime = None,
+        modified_at: datetime = None,
+        id=0,
+    ):
+        self._id = id
+        self._message_delete_timer = message_delete_timer
+        self._notification_chat_id = notification_chat_id
+        self._max_voice_state_hours = max_voice_state_hours
+        self._xp_per_message = xp_per_message
+        self._xp_per_reaction = xp_per_reaction
+        self._max_message_xp_per_hour = max_message_xp_per_hour
+        self._xp_per_ontime_hour = xp_per_ontime_hour
+        self._xp_per_event_participation = xp_per_event_participation
+        self._xp_per_achievement = xp_per_achievement
+        self._afk_command_channel_id = afk_command_channel_id
+        self._help_voice_channel_id = help_voice_channel_id
+        self._team_channel_id = team_channel_id
+        self._login_message_channel_id = login_message_channel_id
+        self._server = server
+        self._afk_channel_ids = afk_channel_ids
+        self._team_role_ids = team_role_ids
+
+        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
+
+    @property
+    def message_delete_timer(self) -> int:
+        return self._message_delete_timer
+
+    @property
+    def notification_chat_id(self) -> int:
+        return self._notification_chat_id
+
+    @property
+    def max_voice_state_hours(self) -> int:
+        return self._max_voice_state_hours
+
+    @property
+    def xp_per_message(self) -> int:
+        return self._xp_per_message
+
+    @property
+    def xp_per_reaction(self) -> int:
+        return self._xp_per_reaction
+
+    @property
+    def max_message_xp_per_hour(self) -> int:
+        return self._max_message_xp_per_hour
+
+    @property
+    def xp_per_ontime_hour(self) -> int:
+        return self._xp_per_ontime_hour
+
+    @property
+    def xp_per_event_participation(self) -> int:
+        return self._xp_per_event_participation
+
+    @property
+    def xp_per_achievement(self) -> int:
+        return self._xp_per_achievement
+
+    @property
+    def afk_command_channel_id(self) -> int:
+        return self._afk_command_channel_id
+
+    @property
+    def help_voice_channel_id(self) -> int:
+        return self._help_voice_channel_id
+
+    @property
+    def team_channel_id(self) -> int:
+        return self._team_channel_id
+
+    @property
+    def login_message_channel_id(self) -> int:
+        return self._login_message_channel_id
+
+    @property
+    def afk_channel_ids(self) -> List[int]:
+        return self._afk_channel_ids
+
+    @property
+    def team_role_ids(self) -> List[ServerTeamRoleIdsConfig]:
+        return self._team_role_ids
+
+    @property
+    def server(self) -> Server:
+        return self._server
+
+    @staticmethod
+    def get_select_all_string() -> str:
+        return str(
+            f"""
+                SELECT * FROM `CFG_Server`;
+            """
+        )
+
+    @staticmethod
+    def get_select_by_id_string(id: int) -> str:
+        return str(
+            f"""
+                SELECT * FROM `CFG_Server`
+                WHERE `Id` = {id};
+            """
+        )
+
+    @property
+    def insert_string(self) -> str:
+        return str(
+            f"""
+                INSERT INTO `CFG_Server` (
+                    `MessageDeleteTimer`,
+                    `NotificationChatId`,
+                    `MaxVoiceStateHours`,
+                    `XpPerMessage`,
+                    `XpPerReaction`,
+                    `MaxMessageXpPerHour`,
+                    `XpPerOntimeHour`,
+                    `XpPerEventParticipation`,
+                    `XpPerAchievement`,
+                    `AFKCommandChannelId`,
+                    `HelpVoiceChannelId`,
+                    `TeamChannelId`,
+                    `LoginMessageChannelId`,
+                    `ServerId`
+                ) VALUES (
+                    {self._message_delete_timer},
+                    {self._notification_chat_id},
+                    {self._max_voice_state_hours},
+                    {self._xp_per_message},
+                    {self._xp_per_reaction},
+                    {self._max_message_xp_per_hour},
+                    {self._xp_per_ontime_hour},
+                    {self._xp_per_event_participation},
+                    {self._xp_per_achievement},
+                    {self._afk_command_channel_id},
+                    {self._help_voice_channel_id},
+                    {self._team_channel_id},
+                    {self._login_message_channel_id},
+                    {self._server.id}
+                );
+            """
+        )
+
+    @property
+    def udpate_string(self) -> str:
+        return str(
+            f"""
+                UPDATE `CFG_Server`
+                SET `MessageDeleteTimer` = {self._message_delete_timer},
+                `NotificationChatId` = {self._notification_chat_id},
+                `MaxVoiceStateHours` = {self._max_voice_state_hours},
+                `XpPerMessage` = {self._xp_per_message},
+                `XpPerReaction` = {self._xp_per_reaction},
+                `MaxMessageXpPerHour` = {self._max_message_xp_per_hour},
+                `XpPerOntimeHour` = {self._xp_per_ontime_hour},
+                `XpPerEventParticipation` = {self._xp_per_event_participation},
+                `XpPerAchievement` = {self._xp_per_achievement},
+                `AFKCommandChannelId` = {self._afk_command_channel_id},
+                `HelpVoiceChannelId` = {self._help_voice_channel_id},
+                `TeamChannelId` = {self._team_channel_id},
+                `LoginMessageChannelId` = {self._login_message_channel_id},
+                `ServerId` = {self._server.id}
+                WHERE `Id` = {self._id};
+            """
+        )
+
+    @property
+    def delete_string(self) -> str:
+        return str(
+            f"""
+                DELETE FROM `CFG_Server`
+                WHERE `Id` = {self._id};
+            """
+        )

kdb-bot/src/bot_data/model/server_team_role_ids_config.py

@@ -0,0 +1,87 @@
+from datetime import datetime
+
+from cpl_core.database import TableABC
+
+from bot_data.model.team_member_type_enum import TeamMemberTypeEnum
+
+
+class ServerTeamRoleIdsConfig(TableABC):
+    def __init__(
+        self,
+        role_id: int,
+        team_member_type: TeamMemberTypeEnum,
+        server_id: int,
+        created_at: datetime = None,
+        modified_at: datetime = None,
+        id=0,
+    ):
+        self._id = id
+        self._role_id = role_id
+        self._team_member_type = team_member_type
+        self._server_id = server_id
+
+        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
+
+    @property
+    def role_id(self) -> int:
+        return self._role_id
+
+    @property
+    def team_member_type(self) -> TeamMemberTypeEnum:
+        return self._team_member_type
+
+    @staticmethod
+    def get_select_all_string() -> str:
+        return str(
+            f"""
+                SELECT * FROM `CFG_ServerTeamRoleIds`;
+            """
+        )
+
+    @staticmethod
+    def get_select_by_id_string(id: int) -> str:
+        return str(
+            f"""
+                SELECT * FROM `CFG_ServerTeamRoleIds`
+                WHERE `Id` = {id};
+            """
+        )
+
+    @property
+    def insert_string(self) -> str:
+        return str(
+            f"""
+                INSERT INTO `CFG_ServerTeamRoleIds` (
+                    `RoleId`,
+                    `TeamMemberType`,
+                    `ServerId`
+                ) VALUES (
+                    {self._role_id},
+                    '{self._team_member_type.value}',
+                    {self._server_id}
+                );
+            """
+        )
+
+    @property
+    def udpate_string(self) -> str:
+        return str(
+            f"""
+                UPDATE `CFG_ServerTeamRoleIds`
+                SET `RoleId` = {self._role_id},
+                `TeamMemberType` = '{self._team_member_type.value}',
+                `ServerId` = {self._server_id}
+                WHERE `Id` = {self._id};
+            """
+        )
+
+    @property
+    def delete_string(self) -> str:
+        return str(
+            f"""
+                DELETE FROM `CFG_ServerTeamRoleIds`
+                WHERE `Id` = {self._id};
+            """
+        )

kdb-bot/src/bot_data/model/team_member_type_enum.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class TeamMemberTypeEnum(Enum):
+    moderator = "Moderator"
+    admin = "Admin"

kdb-bot/src/bot_data/model/technician_config.py

@@ -1,10 +1,11 @@
 from datetime import datetime
 
+from cpl_core.configuration import ConfigurationModelABC
 from cpl_core.database import TableABC
 from cpl_query.extension import List
 
 
-class TechnicianConfig(TableABC):
+class TechnicianConfig(TableABC, ConfigurationModelABC):
     def __init__(
         self,
         help_command_reference_url: str,

kdb-bot/src/bot_data/service/server_config_repository_service.py

@@ -0,0 +1,118 @@
+from cpl_core.database.context import DatabaseContextABC
+from cpl_query.extension import List
+
+from bot_core.logging.database_logger import DatabaseLogger
+from bot_data.abc.server_config_repository_abc import ServerConfigRepositoryABC
+from bot_data.abc.server_repository_abc import ServerRepositoryABC
+from bot_data.model.server_afk_channel_ids_config import ServerAFKChannelIdsConfig
+from bot_data.model.server_config import ServerConfig
+from bot_data.model.server_team_role_ids_config import ServerTeamRoleIdsConfig
+from bot_data.model.team_member_type_enum import TeamMemberTypeEnum
+
+
+class ServerConfigRepositoryService(ServerConfigRepositoryABC):
+    def __init__(self, logger: DatabaseLogger, db_context: DatabaseContextABC, servers: ServerRepositoryABC):
+        ServerConfigRepositoryABC.__init__(self)
+
+        self._logger = logger
+        self._context = db_context
+        self._servers = servers
+
+    def _get_team_role_ids(self, server_team_role_id: int) -> List[ServerTeamRoleIdsConfig]:
+        ids = List(ServerTeamRoleIdsConfig)
+        self._logger.trace(
+            __name__, f"Send SQL command: {ServerTeamRoleIdsConfig.get_select_by_id_string(server_team_role_id)}"
+        )
+        results = self._context.select(ServerTeamRoleIdsConfig.get_select_by_id_string(server_team_role_id))
+        for result in results:
+            self._logger.trace(__name__, f"Got ServerTeamRoleIdsConfig with id {result[0]}")
+            ids.append(
+                ServerTeamRoleIdsConfig(
+                    result[1], TeamMemberTypeEnum(result[2]), result[3], result[4], result[5], id=result[0]
+                )
+            )
+
+        return ids
+
+    def _get_afk_channel_ids(self, server_team_role_id: int) -> List[int]:
+        urls = List(str)
+        self._logger.trace(
+            __name__, f"Send SQL command: {ServerAFKChannelIdsConfig.get_select_by_id_string(server_team_role_id)}"
+        )
+        results = self._context.select(ServerAFKChannelIdsConfig.get_select_by_id_string(server_team_role_id))
+        for result in results:
+            self._logger.trace(__name__, f"Got ServerAFKChannelIdsConfig with id {result[0]}")
+            urls.append(result[1])
+
+        return urls
+
+    def _from_result(self, result: tuple) -> ServerConfig:
+        return ServerConfig(
+            result[1],
+            result[2],
+            result[3],
+            result[4],
+            result[5],
+            result[6],
+            result[7],
+            result[8],
+            result[9],
+            result[10],
+            result[11],
+            result[12],
+            result[13],
+            self._servers.get_server_by_id(result[14]),
+            self._get_afk_channel_ids(result[0]),
+            self._get_team_role_ids(result[0]),
+            result[15],
+            result[16],
+            id=result[0],
+        )
+
+    def does_server_config_exists(self, server_id: int) -> bool:
+        self._logger.trace(__name__, f"Send SQL command: {ServerConfig.get_select_by_id_string(server_id)}")
+        result = self._context.select(ServerConfig.get_select_by_id_string(server_id))
+
+        return len(result) > 0
+
+    def get_server_config(self, server_id: int) -> ServerConfig:
+        self._logger.trace(__name__, f"Send SQL command: {ServerConfig.get_select_by_id_string(server_id)}")
+        result = self._context.select(ServerConfig.get_select_by_id_string(server_id))[0]
+
+        return self._from_result(result)
+
+    def add_server_config(self, server_config: ServerConfig):
+        self._logger.trace(__name__, f"Send SQL command: {server_config.insert_string}")
+        self._context.cursor.execute(server_config.insert_string)
+
+    def update_server_config(self, server_config: ServerConfig):
+        self._logger.trace(__name__, f"Send SQL command: {server_config.udpate_string}")
+        self._context.cursor.execute(server_config.udpate_string)
+
+    def delete_server_config(self, server_config: ServerConfig):
+        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):
+        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):
+        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):
+        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):
+        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):
+        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):
+        self._logger.trace(__name__, f"Send SQL command: {server_afk_channel.delete_string}")
+        self._context.cursor.execute(server_afk_channel.delete_string)

kdb-bot/src/bot_data/service/server_config_seeder.py

@@ -0,0 +1,62 @@
+from cpl_core.database.context import DatabaseContextABC
+from cpl_discord.container import Guild
+from cpl_discord.service import DiscordBotServiceABC
+
+from bot_core.logging.database_logger import DatabaseLogger
+from bot_data.abc.data_seeder_abc import DataSeederABC
+from bot_data.abc.server_config_repository_abc import ServerConfigRepositoryABC
+from bot_data.abc.server_repository_abc import ServerRepositoryABC
+from bot_data.model.server_config import ServerConfig
+
+
+class ServerConfigSeeder(DataSeederABC):
+    def __init__(
+        self,
+        logger: DatabaseLogger,
+        bot: DiscordBotServiceABC,
+        servers: ServerRepositoryABC,
+        server_config: ServerConfigRepositoryABC,
+        db: DatabaseContextABC,
+    ):
+        DataSeederABC.__init__(self)
+
+        self._logger = logger
+        self._bot = bot
+        self._servers = servers
+        self._server_config = server_config
+        self._db = db
+
+    async def seed(self):
+        try:
+            for guild in self._bot.guilds:
+                guild: Guild = guild
+                server = self._servers.get_server_by_discord_id(guild.id)
+                if self._server_config.does_server_config_exists(server.id):
+                    continue
+
+                config = ServerConfig(
+                    6,
+                    guild.system_channel.id,
+                    6,
+                    1,
+                    1,
+                    20,
+                    10,
+                    10,
+                    10,
+                    guild.system_channel.id,
+                    guild.system_channel.id,
+                    guild.system_channel.id,
+                    guild.system_channel.id,
+                    server,
+                    [],
+                    [],
+                )
+
+                self._server_config.add_server_config(config)
+
+                self._db.save_changes()
+                self._logger.debug(__name__, "Seeded technician config")
+
+        except Exception as e:
+            self._logger.error(__name__, f"Seeding technician config failed", e)

kdb-bot/src/bot_data/service/technician_config_seeder.py

@@ -24,25 +24,26 @@ class TechnicianConfigSeeder(DataSeederABC):
 
     async def seed(self):
         try:
-            if not self._technician_config.does_technician_config_exists():
-                config = TechnicianConfig(
-                    "https://git.sh-edraft.de/sh-edraft.de/kd_discord_bot/wiki/Befehle",
-                    8,
-                    8,
-                    1000000,
-                    List(int, [240160344557879316]),
-                    List(str, ["www.google.com", "www.sh-edraft.de", "www.keksdose-gaming.de"]),
-                )
+            if self._technician_config.does_technician_config_exists():
+                return
 
-                self._technician_config.add_technician_config(config)
-                for technician in config.technician_ids:
-                    self._technician_config.add_technician_id_config(TechnicianIdConfig(technician))
+            config = TechnicianConfig(
+                "https://git.sh-edraft.de/sh-edraft.de/kd_discord_bot/wiki/Befehle",
+                8,
+                8,
+                1000000,
+                List(int, [240160344557879316]),
+                List(str, ["www.google.com", "www.sh-edraft.de", "www.keksdose-gaming.de"]),
+            )
 
-                for url in config.ping_urls:
-                    self._technician_config.add_technician_ping_url_config(TechnicianPingUrlConfig(url))
+            self._technician_config.add_technician_config(config)
+            for technician in config.technician_ids:
+                self._technician_config.add_technician_id_config(TechnicianIdConfig(technician))
 
-                self._db.save_changes()
-                self._logger.debug(__name__, "Seeded technician config")
+            for url in config.ping_urls:
+                self._technician_config.add_technician_ping_url_config(TechnicianPingUrlConfig(url))
 
+            self._db.save_changes()
+            self._logger.debug(__name__, "Seeded technician config")
         except Exception as e:
             self._logger.error(__name__, f"Seeding technician config failed", e)