refactor: move db actions into repositories

src/main/java/me/bobert/netneutrality/command/admin/BlacklistCommand.java

@@ -66,12 +66,7 @@ public class BlacklistCommand extends AbstractAdminCommand {
 
         switch (sub) {
             case "get" -> context.async("Retrieving list, please wait...", asyncMessage -> {
-                List<OBlacklist> blacklists = new ArrayList<>();
+                List<OBlacklist> blacklists = repository.getBlacklistForGuild(context.getGuild());
-                try {
-                    blacklists = repository.getBlacklistForGuild(context.getGuild());
-                } catch (Exception e) {
-                    LogHandler.log(e);
-                }
 
                 StringBuilder sb = new StringBuilder();
                 sb.append("List of blacklisted words for this server [").append(context.getGuild().getName()).append("]: \n");
@@ -91,12 +86,6 @@ public class BlacklistCommand extends AbstractAdminCommand {
             case "remove" -> {
                 return repository.delete(context.getGuild(), word);
             }
-            case "disable" -> {
-                return repository.disable(context.getGuild(), word);
-            }
-            case "enable" -> {
-                return repository.enable(context.getGuild(), word);
-            }
         }
 
         return CommandExecutionResult.none();

src/main/java/me/bobert/netneutrality/core/GuildConfigManager.java

@@ -6,25 +6,24 @@ package me.bobert.netneutrality.core;
  * https://discord.gg/qUa6zNFZsd
  */
 
-import me.bobert.netneutrality.core.db.SessionManager;
 import me.bobert.netneutrality.db.GSettings;
 import me.bobert.netneutrality.db.entities.OGuild;
 import me.bobert.netneutrality.db.entities.OGuildSetting;
-import me.bobert.netneutrality.utils.JpaUtils;
+import me.bobert.netneutrality.db.repository.GuildSettingRepository;
 import net.dv8tion.jda.api.entities.Guild;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.hibernate.Session;
 
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
-import java.util.Set;
 
 public class GuildConfigManager {
 
     private static final Logger logger = LogManager.getLogger(GuildConfigManager.class);
     private final Guild guild;
     private final OGuild guildEntity;
+    private final GuildSettingRepository guildSettingRepository = new GuildSettingRepository();
 
     private final Map<String, String> settingsCache = new HashMap<>();
 
@@ -50,33 +49,7 @@ public class GuildConfigManager {
     }
 
     public void setSettingValue(GSettings setting, String value) {
-        Session session = SessionManager.getSessionFactory().openSession();
+        guildSettingRepository.setSettingValue(guildEntity, setting, value);
-        JpaUtils.tryLoad(session, guildEntity, guildEntity.getGuildId());
-
-        OGuildSetting oGuildSetting = guildEntity.getSettingByName(setting.getName());
-
-        session.beginTransaction();
-        if (value == null || setting.getDefaultValue().equals(value)) {
-            if (oGuildSetting != null) {
-                session.remove(oGuildSetting);
-            }
-        } else {
-            if (oGuildSetting == null) {
-                oGuildSetting = new OGuildSetting();
-                oGuildSetting.setGuild(guildEntity);
-                oGuildSetting.setName(setting.getName());
-                oGuildSetting.setValue(value);
-
-                session.persist(oGuildSetting);
-            } else {
-                oGuildSetting.setValue(value);
-
-                session.merge(oGuildSetting);
-            }
-        }
-
-        session.getTransaction().commit();
-        session.close();
 
         reloadSettingsCache();
     }
@@ -85,13 +58,10 @@ public class GuildConfigManager {
         logger.debug("Reloading settings cache for guild: {}", guild.getId());
         settingsCache.clear();
 
-        JpaUtils.getWithSession(guildEntity, session -> {
+        List<OGuildSetting> settings = guildSettingRepository.findByGuild(guild.getId());
-            Set<OGuildSetting> settingSet = guildEntity.getGuildSettings();
+        for (OGuildSetting setting : settings) {
-
-            for (OGuildSetting setting : settingSet) {
             settingsCache.put(setting.getName(), setting.getValue());
         }
-        });
     }
 
 }

src/main/java/me/bobert/netneutrality/core/GuildManager.java

@@ -6,17 +6,15 @@ package me.bobert.netneutrality.core;
  */
 
 import me.bobert.netneutrality.NetNeutrality;
-import me.bobert.netneutrality.core.db.SessionManager;
 import me.bobert.netneutrality.db.entities.OBlacklist;
 import me.bobert.netneutrality.db.entities.OGuild;
+import me.bobert.netneutrality.db.repository.GuildRepository;
 import me.bobert.netneutrality.utils.JpaUtils;
 import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.Role;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.hibernate.Session;
-import org.hibernate.SessionFactory;
 
 import java.util.HashSet;
 import java.util.Map;
@@ -27,22 +25,17 @@ public class GuildManager {
 
     private static final Logger logger = LogManager.getLogger(GuildManager.class);
     private static final Map<String, GuildManager> managers = new ConcurrentHashMap<>();
-    private static final SessionFactory sessionFactory = SessionManager.getSessionFactory();
+    private final GuildRepository guildRepository = new GuildRepository();
     private final Set<String> blacklistCache = new HashSet<>();
     private final GuildConfigManager guildConfigManager;
     private final Guild guild;
     private OGuild guildEntity;
 
-    private GuildManager(String guildId) {
+    private GuildManager(Guild guild) {
-        Guild temp = NetNeutrality.getJDA().getGuildById(guildId);
+        this.guild = guild;
-        if (temp == null)
+        loadGuildFromDb(guild.getId());
-            throw new IllegalArgumentException("Guild does not exist in current cache");
-
-        this.guild = temp;
-        this.guildEntity = loadGuildFromDb(guild.getId());
         this.guildConfigManager = new GuildConfigManager(guild, this.guildEntity);
 
-        managers.put(guild.getId(), this);
         reloadBlacklistCache();
     }
 
@@ -53,9 +46,17 @@ public class GuildManager {
     public static GuildManager getManager(String guildId) {
         if (managers.containsKey(guildId)) {
             return managers.get(guildId);
-        } else {
-            return new GuildManager(guildId);
         }
+
+        Guild temp = NetNeutrality.getJDA().getGuildById(guildId);
+        if (temp == null) {
+            throw new IllegalArgumentException("Guild does not exist in current cache");
+        }
+
+        GuildManager manager = new GuildManager(temp);
+        managers.put(guildId, manager);
+
+        return manager;
     }
 
     // Getter
@@ -107,7 +108,7 @@ public class GuildManager {
         logger.debug("Reloading blacklist cache for guild: {}", guild.getId());
         blacklistCache.clear();
 
-        JpaUtils.getWithSession(guildEntity, session -> {
+        JpaUtils.getWithSession(guildEntity, guildEntity.getGuildId(), session -> {
             Set<OBlacklist> oBlacklistSet = guildEntity.getBlacklists();
 
             for (OBlacklist bl : oBlacklistSet) {
@@ -118,19 +119,16 @@ public class GuildManager {
         });
     }
 
-    private OGuild loadGuildFromDb(String guildId) {
+    private void loadGuildFromDb(String guildId) {
-        Session session = sessionFactory.openSession();
+        JpaUtils.runWithTransaction(session -> {
-        OGuild entity = session.get(OGuild.class, guildId);
+            OGuild entity = guildRepository.findById(guildId);
 
             if (entity == null) {
                 logger.debug("Guild[{}] doesn't exist in DB, creating entity..", guildId);
-            session.beginTransaction();
+
                 entity = new OGuild();
-
                 entity.setGuildId(guildId);
-
                 session.persist(entity);
-            session.getTransaction().commit();
 
                 guild.getTextChannels()
                         .stream()
@@ -138,21 +136,16 @@ public class GuildManager {
                         .forEach(textChannel -> textChannel.sendMessage("Error logging enabled on channel " + textChannel.getAsMention()).queue());
             }
 
-        session.close();
+            guildEntity = entity;
-        return entity;
+        });
     }
 
     public void reloadEntity() {
-        this.guildEntity = loadGuildFromDb(guild.getId());
+        loadGuildFromDb(guild.getId());
     }
 
     public void removeFromDB() {
-        try(Session session = sessionFactory.openSession()) {
+        guildRepository.deleteBy(guild.getId());
-            session.beginTransaction();
-
-            session.remove(guildEntity);
-            session.getTransaction().commit();
-        }
 
         managers.remove(guild.getId());
     }

src/main/java/me/bobert/netneutrality/core/tasks/TaskManager.java

@@ -188,7 +188,7 @@ public class TaskManager {
         }
 
         TaskRepository taskRepository = new TaskRepository();
-        OTask oTask = taskRepository.findByTaskId(task.getId());
+        OTask oTask = taskRepository.findById(task.getId());
         if (oTask == null) {
             oTask = new OTask();
         }

src/main/java/me/bobert/netneutrality/db/Repository.java

@@ -19,6 +19,8 @@ public interface Repository<O> {
 
     List<O> findAll();
 
+    O findById(String id);
+
     default void save(O entity) {
         Transaction transaction = null;
 

src/main/java/me/bobert/netneutrality/db/repository/BlacklistRepository.java

@@ -17,28 +17,32 @@ import net.dv8tion.jda.api.entities.Member;
 import org.hibernate.Session;
 import org.hibernate.query.Query;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public class BlacklistRepository implements Repository<OBlacklist> {
 
     @Override
     public List<OBlacklist> findAll() {
-        List<OBlacklist> blacklists;
+        List<OBlacklist> blacklists = new ArrayList<>();
 
-        try(Session session = SessionManager.getSessionFactory().openSession()) {
+        JpaUtils.runWithSession(session -> {
             Query<OBlacklist> query = session.createQuery("FROM OBlacklist", OBlacklist.class);
 
-            blacklists = query.list();
+            blacklists.addAll(query.list());
-        }
+        });
 
         return blacklists;
     }
 
     @Override
-    public void deleteBy(String id) {
+    public OBlacklist findById(String id) {
-        try(Session session = SessionManager.getSessionFactory().openSession()) {
+        return null;
-            session.beginTransaction();
+    }
 
+    @Override
+    public void deleteBy(String id) {
+        JpaUtils.runWithTransaction(session -> {
             Query<OBlacklist> query = session.createQuery("SELECT o FROM OBlacklist o WHERE o.id = :blacklistId", OBlacklist.class);
             query.setParameter("blacklistId", id);
 
@@ -46,18 +50,16 @@ public class BlacklistRepository implements Repository<OBlacklist> {
             if (oTask != null) {
                 session.remove(oTask);
             }
-
+        });
-            session.getTransaction().commit();
-        }
     }
 
     public CommandExecutionResult add(Guild guild, Member member, String word) {
         GuildManager guildManager = GuildManager.getManager(guild);
 
+        JpaUtils.runWithTransaction(session -> {
             OBlacklist bl = getWordFromDb(word, guild.getId());
+
             if (bl == null) {
-            try(Session session = SessionManager.getSessionFactory().openSession()) {
-                session.beginTransaction();
                 bl = new OBlacklist();
                 bl.setGuild(guildManager.getGuildEntity());
                 bl.setCreatorId(member.getId());
@@ -65,83 +67,37 @@ public class BlacklistRepository implements Repository<OBlacklist> {
                 bl.setEnabled(true);
 
                 session.persist(bl);
-                session.getTransaction().commit();
+            } else {
+                bl.setEnabled(true);
+                session.merge(bl);
             }
+        });
 
         guildManager.reloadBlacklistCache();
         return CommandExecutionResult.success("Added the word [%s] to the blacklist.", word);
     }
 
-        return CommandExecutionResult.info("Word is already blacklisted");
-    }
-
     public CommandExecutionResult delete(Guild guild, String word) {
         GuildManager guildManager = GuildManager.getManager(guild);
 
+        JpaUtils.runWithTransaction(session -> {
             OBlacklist bl = getWordFromDb(word, guild.getId());
             if (bl != null) {
-            try(Session session = SessionManager.getSessionFactory().openSession()) {
-                session.beginTransaction();
                 session.remove(bl);
-                session.getTransaction().commit();
             }
 
+        });
+
         guildManager.reloadBlacklistCache();
         return CommandExecutionResult.success("Removed the word [%s] to the blacklist.", word);
     }
 
-        return CommandExecutionResult.info("Word is not blacklisted");
-    }
-
-    public CommandExecutionResult enable(Guild guild, String word) {
-        GuildManager guildManager = GuildManager.getManager(guild);
-
-        OBlacklist bl = getWordFromDb(word, guild.getId());
-        if (bl != null && !bl.getEnabled()) {
-            try(Session session = SessionManager.getSessionFactory().openSession()) {
-                session.beginTransaction();
-                bl.setEnabled(true);
-                session.merge(bl);
-                session.getTransaction().commit();
-            }
-
-            guildManager.reloadBlacklistCache();
-            return CommandExecutionResult.success("Enabled the word [%s] for the blacklist.", word);
-        }
-
-        return CommandExecutionResult.info("Either word doesn't exist or is already enabled");
-    }
-
-    public CommandExecutionResult disable(Guild guild, String word) {
-        GuildManager guildManager = GuildManager.getManager(guild);
-
-        OBlacklist bl = getWordFromDb(word, guild.getId());
-        if (bl != null && bl.getEnabled()) {
-            try(Session session = SessionManager.getSessionFactory().openSession()) {
-                session.beginTransaction();
-                bl.setEnabled(false);
-                session.merge(bl);
-                session.getTransaction().commit();
-            }
-
-            guildManager.reloadBlacklistCache();
-            return CommandExecutionResult.success("Disabled the word [%s] for the blacklist.", word);
-        }
-
-        return CommandExecutionResult.info("Either word doesn't exist or is already disabled");
-    }
-
     public List<OBlacklist> getBlacklistForGuild(Guild guild) {
-        List<OBlacklist> blacklist;
+        GuildManager manager = GuildManager.getManager(guild);
+        OGuild guildEntity = manager.getGuildEntity();
+        List<OBlacklist> blacklist = new ArrayList<>();
 
-        try(Session session = SessionManager.getSessionFactory().openSession()) {
+        JpaUtils.getWithSession(guildEntity, guildEntity.getGuildId(), session -> blacklist.addAll(guildEntity.getBlacklists()));
-            GuildManager guildManager = GuildManager.getManager(guild);
-
-            OGuild guildEntity = guildManager.getGuildEntity();
-            JpaUtils.tryLoad(session, guildEntity, guildEntity.getGuildId());
-
-            blacklist = guildEntity.getBlacklists().stream().toList();
-        }
 
         return blacklist;
     }

src/main/java/me/bobert/netneutrality/db/repository/GuildRepository.java

@@ -0,0 +1,53 @@
+package me.bobert.netneutrality.db.repository;/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import me.bobert.netneutrality.core.db.SessionManager;
+import me.bobert.netneutrality.db.Repository;
+import me.bobert.netneutrality.db.entities.OGuild;
+import me.bobert.netneutrality.utils.JpaUtils;
+import org.hibernate.Session;
+import org.hibernate.query.Query;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class GuildRepository implements Repository<OGuild> {
+    @Override
+    public List<OGuild> findAll() {
+        List<OGuild> guilds = new ArrayList<>();
+
+        JpaUtils.runWithSession(session -> {
+            Query<OGuild> query = session.createQuery("FROM OGuild", OGuild.class);
+
+            guilds.addAll(query.list());
+        });
+
+        return guilds;
+    }
+
+    @Override
+    public OGuild findById(String id) {
+        try(Session session = SessionManager.getSessionFactory().openSession()) {
+            Query<OGuild> query = session.createQuery("SELECT o FROM OGuild o WHERE o.guildId = :guildId", OGuild.class);
+            query.setParameter("guildId", id);
+
+            return query.uniqueResult();
+        }
+    }
+
+    @Override
+    public void deleteBy(String id) {
+        JpaUtils.runWithTransaction(session -> {
+            Query<OGuild> query = session.createQuery("SELECT o FROM OGuild o WHERE o.guildId = :guildId", OGuild.class);
+            query.setParameter("guildId", id);
+
+            OGuild oGuild = query.uniqueResult();
+            if (oGuild != null) {
+                session.remove(oGuild);
+            }
+        });
+    }
+}

src/main/java/me/bobert/netneutrality/db/repository/GuildSettingRepository.java

@@ -0,0 +1,93 @@
+package me.bobert.netneutrality.db.repository;/*
+ * Copyright (c) anthorob
+ *
+ * https://discord.gg/qUa6zNFZsd
+ */
+
+import me.bobert.netneutrality.core.db.SessionManager;
+import me.bobert.netneutrality.db.GSettings;
+import me.bobert.netneutrality.db.Repository;
+import me.bobert.netneutrality.db.entities.OGuild;
+import me.bobert.netneutrality.db.entities.OGuildSetting;
+import me.bobert.netneutrality.utils.JpaUtils;
+import org.hibernate.Session;
+import org.hibernate.query.Query;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class GuildSettingRepository implements Repository<OGuildSetting> {
+    @Override
+    public List<OGuildSetting> findAll() {
+        List<OGuildSetting> settings = new ArrayList<>();
+
+        JpaUtils.runWithSession(session -> {
+            Query<OGuildSetting> query = session.createQuery("FROM OGuildSetting", OGuildSetting.class);
+
+            settings.addAll(query.list());
+        });
+
+        return settings;
+    }
+
+    @Override
+    public OGuildSetting findById(String id) {
+        try(Session session = SessionManager.getSessionFactory().openSession()) {
+            Query<OGuildSetting> query = session.createQuery("SELECT o FROM OGuildSetting o WHERE o.id = :id", OGuildSetting.class);
+            query.setParameter("id", id);
+
+            return query.uniqueResult();
+        }
+    }
+
+    @Override
+    public void deleteBy(String id) {
+        JpaUtils.runWithTransaction(session -> {
+            Query<OGuildSetting> query = session.createQuery("SELECT o FROM OGuildSetting o WHERE o.id = :id", OGuildSetting.class);
+            query.setParameter("id", id);
+
+            OGuildSetting setting = query.uniqueResult();
+            if (setting != null) {
+                session.remove(setting);
+            }
+        });
+    }
+
+    public List<OGuildSetting> findByGuild(String guildId) {
+        List<OGuildSetting> settings = new ArrayList<>();
+
+        JpaUtils.runWithSession(session -> {
+            Query<OGuildSetting> query = session.createQuery("SELECT o FROM OGuildSetting o WHERE o.guild.guildId = :guildId", OGuildSetting.class);
+            query.setParameter("guildId", guildId);
+
+            settings.addAll(query.list());
+        });
+
+        return settings;
+    }
+
+    public void setSettingValue(OGuild oGuild, GSettings setting, String value) {
+        JpaUtils.getWithSession(oGuild, oGuild.getGuildId(), session -> {
+            OGuildSetting oGuildSetting = oGuild.getSettingByName(setting.getName());
+
+            if (value == null || setting.getDefaultValue().equals(value)) {
+                if (oGuildSetting != null) {
+                    session.remove(oGuildSetting);
+                }
+            } else {
+                if (oGuildSetting == null) {
+                    oGuildSetting = new OGuildSetting();
+                    oGuildSetting.setGuild(oGuild);
+                    oGuildSetting.setName(setting.getName());
+                    oGuildSetting.setValue(value);
+
+                    session.persist(oGuildSetting);
+                } else {
+                    oGuildSetting.setValue(value);
+
+                    session.merge(oGuildSetting);
+                }
+            }
+        });
+    }
+}

src/main/java/me/bobert/netneutrality/db/repository/MessageRepository.java

@@ -9,49 +9,55 @@ import me.bobert.netneutrality.core.GuildManager;
 import me.bobert.netneutrality.core.db.SessionManager;
 import me.bobert.netneutrality.db.Repository;
 import me.bobert.netneutrality.db.entities.OLogMessage;
+import me.bobert.netneutrality.utils.JpaUtils;
 import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
 import org.hibernate.Session;
 import org.hibernate.query.Query;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public class MessageRepository implements Repository<OLogMessage> {
     @Override
     public List<OLogMessage> findAll() {
-        List<OLogMessage> messages;
+        List<OLogMessage> messages = new ArrayList<>();
 
-        try(Session session = SessionManager.getSessionFactory().openSession()) {
+        JpaUtils.runWithSession(session -> {
             Query<OLogMessage> query = session.createQuery("FROM OLogMessage", OLogMessage.class);
 
-            messages = query.list();
+            messages.addAll(query.list());
-        }
+        });
 
         return messages;
     }
 
     @Override
-    public void deleteBy(String id) {
+    public OLogMessage findById(String id) {
         try(Session session = SessionManager.getSessionFactory().openSession()) {
-            session.beginTransaction();
+            Query<OLogMessage> query = session.createQuery("SELECT o FROM OLogMessage o WHERE o.messageId = :messageId", OLogMessage.class);
+            query.setParameter("messageId", id);
 
-            Query<OLogMessage> query = session.createQuery("SELECT o FROM OLogMessage o WHERE o.id = :messageId", OLogMessage.class);
+            return query.uniqueResult();
+        }
+    }
+
+    @Override
+    public void deleteBy(String id) {
+        JpaUtils.runWithTransaction(session -> {
+            Query<OLogMessage> query = session.createQuery("SELECT o FROM OLogMessage o WHERE o.messageId = :messageId", OLogMessage.class);
             query.setParameter("messageId", id);
 
             OLogMessage oLogMessage = query.uniqueResult();
             if (oLogMessage != null) {
                 session.remove(oLogMessage);
             }
-
+        });
-            session.getTransaction().commit();
-        }
     }
 
     public void log(GuildManager guildManager, MessageChannel channel, Member author, Message message) {
-        try(Session session = SessionManager.getSessionFactory().openSession()) {
+        JpaUtils.runWithTransaction(session -> {
-            session.beginTransaction();
-
             OLogMessage logMessage = new OLogMessage();
             logMessage.setGuild(guildManager.getGuildEntity());
             logMessage.setMessageId(message.getId());
@@ -61,61 +67,39 @@ public class MessageRepository implements Repository<OLogMessage> {
             logMessage.setDateSent(message.getTimeCreated().toInstant());
 
             session.persist(logMessage);
-            session.getTransaction().commit();
+        });
-        }
     }
 
     public void logEdit(String messageId, String newMessage) {
-        try(Session session = SessionManager.getSessionFactory().openSession()) {
+        JpaUtils.runWithTransaction(session -> {
-            Query<OLogMessage> query = session.createQuery("SELECT o FROM OLogMessage o WHERE o.id = :messageId", OLogMessage.class);
+            Query<OLogMessage> query = session.createQuery("SELECT o FROM OLogMessage o WHERE o.messageId = :messageId", OLogMessage.class);
             query.setParameter("messageId", messageId);
 
             OLogMessage message = query.uniqueResult();
             if (message != null) {
-                session.beginTransaction();
                 message.setEditedMessage(newMessage);
 
                 session.merge(message);
-                session.getTransaction().commit();
             }
-        }
+        });
-    }
-
-    public OLogMessage getMessage(String messageId) {
-        try(Session session = SessionManager.getSessionFactory().openSession()) {
-            Query<OLogMessage> query = session.createQuery("SELECT o FROM OLogMessage o WHERE o.id = :messageId", OLogMessage.class);
-            query.setParameter("messageId", messageId);
-
-            return query.uniqueResult();
-        }
-
     }
 
     public List<OLogMessage> getMessagesFromUser(String userId, String guildId, int max) {
-        try(Session session = SessionManager.getSessionFactory().openSession()) {
+        List<OLogMessage> messages = new ArrayList<>();
-            Query<OLogMessage> query = session.createQuery(
+
-                    "SELECT o FROM OLogMessage o WHERE o.guild.guildId = :guildId AND o.userId = :userId",
+        JpaUtils.runWithSession(session -> {
-                    OLogMessage.class
+            Query<OLogMessage> query = session.createQuery("SELECT o FROM OLogMessage o WHERE o.guild.guildId = :guildId AND o.userId = :userId", OLogMessage.class);
-            );
             query.setParameter("guildId", guildId);
             query.setParameter("userId", userId);
             query.setMaxResults(max);
 
-            return query.getResultList();
+            messages.addAll(query.list());
-        }
+        });
+
+        return messages;
     }
 
     public String getMessageString(String messageId) {
-        try(Session session = SessionManager.getSessionFactory().openSession()) {
+        return findById(messageId).getMessage();
-            Query<OLogMessage> query = session.createQuery("SELECT o FROM OLogMessage o WHERE o.id = :messageId", OLogMessage.class);
-            query.setParameter("messageId", messageId);
-
-            OLogMessage message = query.uniqueResult();
-            if (message != null) {
-                return message.getMessage();
-            }
-
-            return null;
-        }
     }
 }

src/main/java/me/bobert/netneutrality/db/repository/TaskRepository.java

@@ -9,11 +9,13 @@ package me.bobert.netneutrality.db.repository;
 import me.bobert.netneutrality.core.db.SessionManager;
 import me.bobert.netneutrality.db.Repository;
 import me.bobert.netneutrality.db.entities.OTask;
+import me.bobert.netneutrality.utils.JpaUtils;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.hibernate.Session;
 import org.hibernate.query.Query;
 
+import java.util.ArrayList;
 import java.util.List;
 
 public class TaskRepository implements Repository<OTask> {
@@ -21,18 +23,19 @@ public class TaskRepository implements Repository<OTask> {
 
     @Override
     public List<OTask> findAll() {
-        List<OTask> tasks;
+        List<OTask> tasks = new ArrayList<>();
 
-        try(Session session = SessionManager.getSessionFactory().openSession()) {
+        JpaUtils.runWithSession(session -> {
             Query<OTask> query = session.createQuery("FROM OTask", OTask.class);
 
-            tasks = query.list();
+            tasks.addAll(query.list());
-        }
+        });
 
         return tasks;
     }
 
-    public OTask findByTaskId(String id) {
+    @Override
+    public OTask findById(String id) {
         try(Session session = SessionManager.getSessionFactory().openSession()) {
             Query<OTask> query = session.createQuery("SELECT o FROM OTask o WHERE o.taskId = :taskId", OTask.class);
             query.setParameter("taskId", id);
@@ -43,9 +46,7 @@ public class TaskRepository implements Repository<OTask> {
 
     @Override
     public void deleteBy(String id) {
-        try(Session session = SessionManager.getSessionFactory().openSession()) {
+        JpaUtils.runWithTransaction(session -> {
-            session.beginTransaction();
-
             Query<OTask> query = session.createQuery("SELECT o FROM OTask o WHERE o.taskId = :taskId", OTask.class);
             query.setParameter("taskId", id);
 
@@ -53,8 +54,6 @@ public class TaskRepository implements Repository<OTask> {
             if (oTask != null) {
                 session.remove(oTask);
             }
-
+        });
-            session.getTransaction().commit();
-        }
     }
 }

src/main/java/me/bobert/netneutrality/hooks/message/EditHandler.java

@@ -32,9 +32,7 @@ public class EditHandler extends ListenerAdapter {
             OGuild guildEntity = guildManager.getGuildEntity();
 
             if (guildEntity.getLogChannel() != null && !guildEntity.getLogChannel().isEmpty()) {
-                Session session = SessionManager.getSessionFactory().openSession();
+                JpaUtils.getWithSession(guildEntity, guildEntity.getGuildId(), session -> {
-                JpaUtils.tryLoad(session, guildEntity, guildEntity.getGuildId());
-
                     int size = guildEntity.getLoggings()
                             .stream()
                             .filter(oLogging -> oLogging.getId().getChannelId().equals(event.getChannel().getId()) && oLogging.getEnabled())
@@ -52,6 +50,7 @@ public class EditHandler extends ListenerAdapter {
                             channel.sendMessageEmbeds(MessageFunction.buildEditMessage(event.getMember(), event.getMessage(), originalMessage)).queue();
                         }
                     }
+                });
             }
         }
     }

src/main/java/me/bobert/netneutrality/utils/JpaUtils.java

@@ -14,13 +14,15 @@ import org.apache.logging.log4j.Logger;
 import org.hibernate.HibernateException;
 import org.hibernate.ObjectNotFoundException;
 import org.hibernate.Session;
+import org.hibernate.Transaction;
+import org.hibernate.exception.ConstraintViolationException;
 
 import java.io.Serializable;
 import java.util.function.Consumer;
 
 public class JpaUtils {
 
-    private static final Logger log = LogManager.getLogger(JpaUtils.class);
+    private static final Logger logger = LogManager.getLogger(JpaUtils.class);
 
     /**
      * Tries to read the persistent state into the object.
@@ -41,12 +43,12 @@ public class JpaUtils {
             if (exception instanceof ObjectNotFoundException) {
                 if (object instanceof OGuild oGuild) {
                     String cachedId = oGuild.getGuildId();
-                    log.error("Trying to load Guild[{}] while entity doesn't exist in database, reloading..", cachedId);
+                    logger.error("Trying to load Guild[{}] while entity doesn't exist in database, reloading..", cachedId);
 
                     GuildManager guildManager = GuildManager.getManager(cachedId);
                     guildManager.reloadEntity();
                     guildManager.getBlacklistCache().clear();
-                    log.info("Guild[{}] reloaded", cachedId);
+                    logger.info("Guild[{}] reloaded", cachedId);
                 }
             }
 
@@ -55,23 +57,42 @@ public class JpaUtils {
         }
     }
 
-    public static void updateWithTransaction(Object persistantEntity, Runnable runnable) {
+    public static void runWithSession(Consumer<Session> consumer) {
+        try(Session session = SessionManager.getSessionFactory().openSession()) {
+            consumer.accept(session);
+        }
+    }
+
+    public static void runWithTransaction(Consumer<Session> consumer) {
         try(Session session = SessionManager.getSessionFactory().openSession()) {
             session.beginTransaction();
-
+            consumer.accept(session);
-            runnable.run();
-
-            session.merge(persistantEntity);
             session.getTransaction().commit();
         }
     }
 
-    public static void getWithSession(OGuild oGuild, Consumer<Session> consumer) {
+    public static void updateWithTransaction(Object persistantEntity, Runnable runnable) {
-        getWithSession(oGuild, oGuild.getGuildId(), consumer);
+        try(Session session = SessionManager.getSessionFactory().openSession()) {
+            Transaction transaction = session.beginTransaction();
+
+            try {
+                runnable.run();
+
+                session.merge(persistantEntity);
+                transaction.commit();
+            } catch (ConstraintViolationException e) {
+                logger.error(e);
+                throw e;
+            } catch (Exception e) {
+                logger.error(e);
+                transaction.rollback();
+            }
+        }
     }
 
     /**
-     * Loads the entity and relations from the database and executes the given consumer
+     * Loads the entity and relations from the database and executes the given consumer.
+     * This will load all Lazy relationships defined in the entity.
      *
      * @param persistantEntity The entity to load
      * @param id The identifier for the entity