anthorob/netneutrality
1
0 Fork 0
Code Issues 1 Pull Requests 10 Actions Packages Projects Releases Wiki Activity

refactor: move db actions into repositories

Browse Source
This commit is contained in:
anthorob committed 2024-10-03 09:48:43 -04:00
1 parent 5294cb86ca
commit 9ee4797aaf
12 files changed
+312 -253
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/main/java/me/bobert/netneutrality/command/admin/BlacklistCommand.java
+1 -12
View File
@@ -66,12 +66,7 @@ public class BlacklistCommand extends AbstractAdminCommand {
switch (sub) { switch (sub) {
case "get" -> context.async("Retrieving list, please wait...", asyncMessage -> { 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(); StringBuilder sb = new StringBuilder();
sb.append("List of blacklisted words for this server [").append(context.getGuild().getName()).append("]: \n"); 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" -> { case "remove" -> {
return repository.delete(context.getGuild(), word); 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(); return CommandExecutionResult.none();
src/main/java/me/bobert/netneutrality/core/GuildConfigManager.java
+8 -38
View File
@@ -6,25 +6,24 @@ package me.bobert.netneutrality.core;
* https://discord.gg/qUa6zNFZsd * https://discord.gg/qUa6zNFZsd
*/ */
import me.bobert.netneutrality.core.db.SessionManager;
import me.bobert.netneutrality.db.GSettings; import me.bobert.netneutrality.db.GSettings;
import me.bobert.netneutrality.db.entities.OGuild; import me.bobert.netneutrality.db.entities.OGuild;
import me.bobert.netneutrality.db.entities.OGuildSetting; 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 net.dv8tion.jda.api.entities.Guild;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import org.hibernate.Session;
import java.util.HashMap; import java.util.HashMap;
import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Set;
public class GuildConfigManager { public class GuildConfigManager {
private static final Logger logger = LogManager.getLogger(GuildConfigManager.class); private static final Logger logger = LogManager.getLogger(GuildConfigManager.class);
private final Guild guild; private final Guild guild;
private final OGuild guildEntity; private final OGuild guildEntity;
private final GuildSettingRepository guildSettingRepository = new GuildSettingRepository();
private final Map<String, String> settingsCache = new HashMap<>(); private final Map<String, String> settingsCache = new HashMap<>();
@@ -50,33 +49,7 @@ public class GuildConfigManager {
} }
public void setSettingValue(GSettings setting, String value) { 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(); reloadSettingsCache();
} }
@@ -85,13 +58,10 @@ public class GuildConfigManager {
logger.debug("Reloading settings cache for guild: {}", guild.getId()); logger.debug("Reloading settings cache for guild: {}", guild.getId());
settingsCache.clear(); settingsCache.clear();
JpaUtils.getWithSession(guildEntity, session -> { List<OGuildSetting> settings = guildSettingRepository.findByGuild(guild.getId());
Set<OGuildSetting> settingSet = guildEntity.getGuildSettings(); for (OGuildSetting setting : settings) {
settingsCache.put(setting.getName(), setting.getValue());
for (OGuildSetting setting : settingSet) { }
settingsCache.put(setting.getName(), setting.getValue());
}
});
} }
} }
src/main/java/me/bobert/netneutrality/core/GuildManager.java
+33 -40
View File
@@ -6,17 +6,15 @@ package me.bobert.netneutrality.core;
*/ */
import me.bobert.netneutrality.NetNeutrality; 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.OBlacklist;
import me.bobert.netneutrality.db.entities.OGuild; import me.bobert.netneutrality.db.entities.OGuild;
import me.bobert.netneutrality.db.repository.GuildRepository;
import me.bobert.netneutrality.utils.JpaUtils; import me.bobert.netneutrality.utils.JpaUtils;
import net.dv8tion.jda.api.entities.Guild; import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Member; import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Role; import net.dv8tion.jda.api.entities.Role;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import java.util.HashSet; import java.util.HashSet;
import java.util.Map; import java.util.Map;
@@ -27,22 +25,17 @@ public class GuildManager {
private static final Logger logger = LogManager.getLogger(GuildManager.class); private static final Logger logger = LogManager.getLogger(GuildManager.class);
private static final Map<String, GuildManager> managers = new ConcurrentHashMap<>(); 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 Set<String> blacklistCache = new HashSet<>();
private final GuildConfigManager guildConfigManager; private final GuildConfigManager guildConfigManager;
private final Guild guild; private final Guild guild;
private OGuild guildEntity; 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); this.guildConfigManager = new GuildConfigManager(guild, this.guildEntity);
managers.put(guild.getId(), this);
reloadBlacklistCache(); reloadBlacklistCache();
} }
@@ -53,9 +46,17 @@ public class GuildManager {
public static GuildManager getManager(String guildId) { public static GuildManager getManager(String guildId) {
if (managers.containsKey(guildId)) { if (managers.containsKey(guildId)) {
return managers.get(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 // Getter
@@ -107,7 +108,7 @@ public class GuildManager {
logger.debug("Reloading blacklist cache for guild: {}", guild.getId()); logger.debug("Reloading blacklist cache for guild: {}", guild.getId());
blacklistCache.clear(); blacklistCache.clear();
JpaUtils.getWithSession(guildEntity, session -> { JpaUtils.getWithSession(guildEntity, guildEntity.getGuildId(), session -> {
Set<OBlacklist> oBlacklistSet = guildEntity.getBlacklists(); Set<OBlacklist> oBlacklistSet = guildEntity.getBlacklists();
for (OBlacklist bl : oBlacklistSet) { for (OBlacklist bl : oBlacklistSet) {
@@ -118,41 +119,33 @@ 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) { if (entity == null) {
logger.debug("Guild[{}] doesn't exist in DB, creating entity..", guildId); logger.debug("Guild[{}] doesn't exist in DB, creating entity..", guildId);
session.beginTransaction();
entity = new OGuild();
entity.setGuildId(guildId); entity = new OGuild();
entity.setGuildId(guildId);
session.persist(entity);
session.persist(entity); guild.getTextChannels()
session.getTransaction().commit(); .stream()
.filter(textChannel -> textChannel.getName().equals("debug") || textChannel.getName().equals("log"))
.forEach(textChannel -> textChannel.sendMessage("Error logging enabled on channel " + textChannel.getAsMention()).queue());
}
guild.getTextChannels() guildEntity = entity;
.stream() });
.filter(textChannel -> textChannel.getName().equals("debug") || textChannel.getName().equals("log"))
.forEach(textChannel -> textChannel.sendMessage("Error logging enabled on channel " + textChannel.getAsMention()).queue());
}
session.close();
return entity;
} }
public void reloadEntity() { public void reloadEntity() {
this.guildEntity = loadGuildFromDb(guild.getId()); loadGuildFromDb(guild.getId());
} }
public void removeFromDB() { public void removeFromDB() {
try(Session session = sessionFactory.openSession()) { guildRepository.deleteBy(guild.getId());
session.beginTransaction();
session.remove(guildEntity);
session.getTransaction().commit();
}
managers.remove(guild.getId()); managers.remove(guild.getId());
} }
src/main/java/me/bobert/netneutrality/core/tasks/TaskManager.java
+1 -1
View File
@@ -188,7 +188,7 @@ public class TaskManager {
} }
TaskRepository taskRepository = new TaskRepository(); TaskRepository taskRepository = new TaskRepository();
OTask oTask = taskRepository.findByTaskId(task.getId()); OTask oTask = taskRepository.findById(task.getId());
if (oTask == null) { if (oTask == null) {
oTask = new OTask(); oTask = new OTask();
} }
src/main/java/me/bobert/netneutrality/db/Repository.java
+2
View File
@@ -19,6 +19,8 @@ public interface Repository<O> {
List<O> findAll(); List<O> findAll();
O findById(String id);
default void save(O entity) { default void save(O entity) {
Transaction transaction = null; Transaction transaction = null;
src/main/java/me/bobert/netneutrality/db/repository/BlacklistRepository.java
+32 -76
View File
@@ -17,28 +17,32 @@ import net.dv8tion.jda.api.entities.Member;
import org.hibernate.Session; import org.hibernate.Session;
import org.hibernate.query.Query; import org.hibernate.query.Query;
import java.util.ArrayList;
import java.util.List; import java.util.List;
public class BlacklistRepository implements Repository<OBlacklist> { public class BlacklistRepository implements Repository<OBlacklist> {
@Override @Override
public List<OBlacklist> findAll() { 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); Query<OBlacklist> query = session.createQuery("FROM OBlacklist", OBlacklist.class);
blacklists = query.list(); blacklists.addAll(query.list());
} });
return blacklists; return blacklists;
} }
@Override @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<OBlacklist> query = session.createQuery("SELECT o FROM OBlacklist o WHERE o.id = :blacklistId", OBlacklist.class);
query.setParameter("blacklistId", id); query.setParameter("blacklistId", id);
@@ -46,18 +50,16 @@ public class BlacklistRepository implements Repository<OBlacklist> {
if (oTask != null) { if (oTask != null) {
session.remove(oTask); session.remove(oTask);
} }
});
session.getTransaction().commit();
}
} }
public CommandExecutionResult add(Guild guild, Member member, String word) { public CommandExecutionResult add(Guild guild, Member member, String word) {
GuildManager guildManager = GuildManager.getManager(guild); GuildManager guildManager = GuildManager.getManager(guild);
OBlacklist bl = getWordFromDb(word, guild.getId()); JpaUtils.runWithTransaction(session -> {
if (bl == null) { OBlacklist bl = getWordFromDb(word, guild.getId());
try(Session session = SessionManager.getSessionFactory().openSession()) {
session.beginTransaction(); if (bl == null) {
bl = new OBlacklist(); bl = new OBlacklist();
bl.setGuild(guildManager.getGuildEntity()); bl.setGuild(guildManager.getGuildEntity());
bl.setCreatorId(member.getId()); bl.setCreatorId(member.getId());
@@ -65,83 +67,37 @@ public class BlacklistRepository implements Repository<OBlacklist> {
bl.setEnabled(true); bl.setEnabled(true);
session.persist(bl); session.persist(bl);
session.getTransaction().commit(); } else {
bl.setEnabled(true);
session.merge(bl);
} }
});
guildManager.reloadBlacklistCache(); guildManager.reloadBlacklistCache();
return CommandExecutionResult.success("Added the word [%s] to the blacklist.", word); 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) { public CommandExecutionResult delete(Guild guild, String word) {
GuildManager guildManager = GuildManager.getManager(guild); GuildManager guildManager = GuildManager.getManager(guild);
OBlacklist bl = getWordFromDb(word, guild.getId()); JpaUtils.runWithTransaction(session -> {
if (bl != null) { OBlacklist bl = getWordFromDb(word, guild.getId());
try(Session session = SessionManager.getSessionFactory().openSession()) { if (bl != null) {
session.beginTransaction();
session.remove(bl); 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"); guildManager.reloadBlacklistCache();
} return CommandExecutionResult.success("Removed the word [%s] to the blacklist.", word);
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) { 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; return blacklist;
} }
src/main/java/me/bobert/netneutrality/db/repository/GuildRepository.java
+53
View File
@@ -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
+93
View File
@@ -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
+32 -48
View File
@@ -9,49 +9,55 @@ import me.bobert.netneutrality.core.GuildManager;
import me.bobert.netneutrality.core.db.SessionManager; import me.bobert.netneutrality.core.db.SessionManager;
import me.bobert.netneutrality.db.Repository; import me.bobert.netneutrality.db.Repository;
import me.bobert.netneutrality.db.entities.OLogMessage; 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.Member;
import net.dv8tion.jda.api.entities.Message; import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel; import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
import org.hibernate.Session; import org.hibernate.Session;
import org.hibernate.query.Query; import org.hibernate.query.Query;
import java.util.ArrayList;
import java.util.List; import java.util.List;
public class MessageRepository implements Repository<OLogMessage> { public class MessageRepository implements Repository<OLogMessage> {
@Override @Override
public List<OLogMessage> findAll() { 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); Query<OLogMessage> query = session.createQuery("FROM OLogMessage", OLogMessage.class);
messages = query.list(); messages.addAll(query.list());
} });
return messages; return messages;
} }
@Override @Override
public void deleteBy(String id) { public OLogMessage findById(String id) {
try(Session session = SessionManager.getSessionFactory().openSession()) { 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); query.setParameter("messageId", id);
OLogMessage oLogMessage = query.uniqueResult(); OLogMessage oLogMessage = query.uniqueResult();
if (oLogMessage != null) { if (oLogMessage != null) {
session.remove(oLogMessage); session.remove(oLogMessage);
} }
});
session.getTransaction().commit();
}
} }
public void log(GuildManager guildManager, MessageChannel channel, Member author, Message message) { 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(); OLogMessage logMessage = new OLogMessage();
logMessage.setGuild(guildManager.getGuildEntity()); logMessage.setGuild(guildManager.getGuildEntity());
logMessage.setMessageId(message.getId()); logMessage.setMessageId(message.getId());
@@ -61,61 +67,39 @@ public class MessageRepository implements Repository<OLogMessage> {
logMessage.setDateSent(message.getTimeCreated().toInstant()); logMessage.setDateSent(message.getTimeCreated().toInstant());
session.persist(logMessage); session.persist(logMessage);
session.getTransaction().commit(); });
}
} }
public void logEdit(String messageId, String newMessage) { 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); query.setParameter("messageId", messageId);
OLogMessage message = query.uniqueResult(); OLogMessage message = query.uniqueResult();
if (message != null) { if (message != null) {
session.beginTransaction();
message.setEditedMessage(newMessage); message.setEditedMessage(newMessage);
session.merge(message); 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) { 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("guildId", guildId);
query.setParameter("userId", userId); query.setParameter("userId", userId);
query.setMaxResults(max); query.setMaxResults(max);
return query.getResultList(); messages.addAll(query.list());
} });
return messages;
} }
public String getMessageString(String messageId) { 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
+10 -11
View File
@@ -9,11 +9,13 @@ package me.bobert.netneutrality.db.repository;
import me.bobert.netneutrality.core.db.SessionManager; import me.bobert.netneutrality.core.db.SessionManager;
import me.bobert.netneutrality.db.Repository; import me.bobert.netneutrality.db.Repository;
import me.bobert.netneutrality.db.entities.OTask; import me.bobert.netneutrality.db.entities.OTask;
import me.bobert.netneutrality.utils.JpaUtils;
import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger; import org.apache.logging.log4j.Logger;
import org.hibernate.Session; import org.hibernate.Session;
import org.hibernate.query.Query; import org.hibernate.query.Query;
import java.util.ArrayList;
import java.util.List; import java.util.List;
public class TaskRepository implements Repository<OTask> { public class TaskRepository implements Repository<OTask> {
@@ -21,18 +23,19 @@ public class TaskRepository implements Repository<OTask> {
@Override @Override
public List<OTask> findAll() { 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); Query<OTask> query = session.createQuery("FROM OTask", OTask.class);
tasks = query.list(); tasks.addAll(query.list());
} });
return tasks; return tasks;
} }
public OTask findByTaskId(String id) { @Override
public OTask findById(String id) {
try(Session session = SessionManager.getSessionFactory().openSession()) { try(Session session = SessionManager.getSessionFactory().openSession()) {
Query<OTask> query = session.createQuery("SELECT o FROM OTask o WHERE o.taskId = :taskId", OTask.class); Query<OTask> query = session.createQuery("SELECT o FROM OTask o WHERE o.taskId = :taskId", OTask.class);
query.setParameter("taskId", id); query.setParameter("taskId", id);
@@ -43,9 +46,7 @@ public class TaskRepository implements Repository<OTask> {
@Override @Override
public void deleteBy(String id) { 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<OTask> query = session.createQuery("SELECT o FROM OTask o WHERE o.taskId = :taskId", OTask.class);
query.setParameter("taskId", id); query.setParameter("taskId", id);
@@ -53,8 +54,6 @@ public class TaskRepository implements Repository<OTask> {
if (oTask != null) { if (oTask != null) {
session.remove(oTask); session.remove(oTask);
} }
});
session.getTransaction().commit();
}
} }
} }
src/main/java/me/bobert/netneutrality/hooks/message/EditHandler.java
+15 -16
View File
@@ -32,26 +32,25 @@ public class EditHandler extends ListenerAdapter {
OGuild guildEntity = guildManager.getGuildEntity(); OGuild guildEntity = guildManager.getGuildEntity();
if (guildEntity.getLogChannel() != null && !guildEntity.getLogChannel().isEmpty()) { 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())
.collect(Collectors.toSet())
.size();
int size = guildEntity.getLoggings() if (size > 0) {
.stream() TextChannel channel = event.getGuild().getTextChannelById(guildEntity.getLogChannel());
.filter(oLogging -> oLogging.getId().getChannelId().equals(event.getChannel().getId()) && oLogging.getEnabled())
.collect(Collectors.toSet())
.size();
if (size > 0) { if (channel != null) {
TextChannel channel = event.getGuild().getTextChannelById(guildEntity.getLogChannel()); MessageRepository repository = new MessageRepository();
String originalMessage = repository.getMessageString(event.getMessage().getId());
repository.logEdit(event.getMessage().getId(), event.getMessage().getContentDisplay());
if (channel != null) { channel.sendMessageEmbeds(MessageFunction.buildEditMessage(event.getMember(), event.getMessage(), originalMessage)).queue();
MessageRepository repository = new MessageRepository(); }
String originalMessage = repository.getMessageString(event.getMessage().getId());
repository.logEdit(event.getMessage().getId(), event.getMessage().getContentDisplay());
channel.sendMessageEmbeds(MessageFunction.buildEditMessage(event.getMember(), event.getMessage(), originalMessage)).queue();
} }
} });
} }
} }
} }
src/main/java/me/bobert/netneutrality/utils/JpaUtils.java
+32 -11
View File
@@ -14,13 +14,15 @@ import org.apache.logging.log4j.Logger;
import org.hibernate.HibernateException; import org.hibernate.HibernateException;
import org.hibernate.ObjectNotFoundException; import org.hibernate.ObjectNotFoundException;
import org.hibernate.Session; import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.exception.ConstraintViolationException;
import java.io.Serializable; import java.io.Serializable;
import java.util.function.Consumer; import java.util.function.Consumer;
public class JpaUtils { 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. * Tries to read the persistent state into the object.
@@ -41,12 +43,12 @@ public class JpaUtils {
if (exception instanceof ObjectNotFoundException) { if (exception instanceof ObjectNotFoundException) {
if (object instanceof OGuild oGuild) { if (object instanceof OGuild oGuild) {
String cachedId = oGuild.getGuildId(); 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 guildManager = GuildManager.getManager(cachedId);
guildManager.reloadEntity(); guildManager.reloadEntity();
guildManager.getBlacklistCache().clear(); 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()) { try(Session session = SessionManager.getSessionFactory().openSession()) {
session.beginTransaction(); session.beginTransaction();
consumer.accept(session);
runnable.run();
session.merge(persistantEntity);
session.getTransaction().commit(); 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 persistantEntity The entity to load
* @param id The identifier for the entity * @param id The identifier for the entity