Sheldan/abstracto
1
0
Fork 0
mirror of https://github.com/Sheldan/abstracto.git synced 2026-04-25 14:53:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

[AB-139] changing the places at which there might be an uncached member object

Browse Source 
fixing integer validator
fixing syncing roles not working if the role did not change in the database
fixing warn id being flipped
fixing star stats model
This commit is contained in:
Sheldan
2020-10-11 22:04:18 +02:00
parent 1d3c414d6b
commit 36d11371cb
105 changed files with 1762 additions and 1086 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/DeleteWarning.java
View File

@@ -31,7 +31,7 @@ public class DeleteWarning extends AbstractConditionableCommand {
public CommandResult execute(CommandContext commandContext) {
checkParameters(commandContext);
Long warnId = (Long) commandContext.getParameters().getParameters().get(0);
Optional<Warning> optional = warnManagementService.findById(warnId, commandContext.getGuild().getIdLong());
Optional<Warning> optional = warnManagementService.findByIdOptional(warnId, commandContext.getGuild().getIdLong());
optional.ifPresent(warning -> warnManagementService.deleteWarning(warning));
return CommandResult.fromSuccess();
}

10
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/UserNotes.java
View File

@@ -18,6 +18,7 @@ import dev.sheldan.abstracto.moderation.config.features.ModerationFeatures;
import dev.sheldan.abstracto.moderation.converter.UserNotesConverter;
import dev.sheldan.abstracto.moderation.models.database.UserNote;
import dev.sheldan.abstracto.moderation.models.template.commands.ListNotesModel;
import dev.sheldan.abstracto.moderation.models.template.commands.NoteEntryModel;
import dev.sheldan.abstracto.moderation.service.management.UserNoteManagementService;
import dev.sheldan.abstracto.templating.service.TemplateService;
import net.dv8tion.jda.api.entities.Member;
@@ -66,9 +67,12 @@ public class UserNotes extends AbstractConditionableCommand {
} else {
userNotes = userNoteManagementService.loadNotesForServer(commandContext.getUserInitiatedContext().getServer());
}
model.setUserNotes(userNotesConverter.fromNotes(userNotes));
return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInChannel(USER_NOTES_RESPONSE_TEMPLATE, model, commandContext.getChannel()))
.thenApply(aVoid -> CommandResult.fromSuccess());
CompletableFuture<List<NoteEntryModel>> listCompletableFuture = userNotesConverter.fromNotes(userNotes);
return listCompletableFuture.thenCompose(noteEntryModels -> {
model.setUserNotes(noteEntryModels);
return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInChannel(USER_NOTES_RESPONSE_TEMPLATE, model, commandContext.getChannel()))
.thenApply(aVoid -> CommandResult.fromSuccess());
});
}
@Override

21
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/Warnings.java
View File

@@ -22,9 +22,11 @@ import dev.sheldan.abstracto.moderation.service.management.WarnManagementService
import net.dv8tion.jda.api.entities.Member;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
@Component
public class Warnings extends AbstractConditionableCommand {
@@ -45,8 +47,11 @@ public class Warnings extends AbstractConditionableCommand {
@Autowired
private EventWaiter eventWaiter;
@Autowired
private Warnings self;
@Override
public CommandResult execute(CommandContext commandContext) {
public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
checkParameters(commandContext);
List<Warning> warnsToDisplay;
if(!commandContext.getParameters().getParameters().isEmpty()) {
@@ -55,14 +60,21 @@ public class Warnings extends AbstractConditionableCommand {
} else {
warnsToDisplay = warnManagementService.getAllWarningsOfServer(commandContext.getUserInitiatedContext().getServer());
}
List<WarnEntry> warnEntries = warnEntryConverter.fromWarnings(warnsToDisplay);
return warnEntryConverter.fromWarnings(warnsToDisplay).thenApply(warnEntries -> {
self.renderWarnings(commandContext, warnEntries);
return CommandResult.fromSuccess();
});
WarningsModel model = (WarningsModel) ContextConverter.fromCommandContext(commandContext, WarningsModel.class);
}
@Transactional
public void renderWarnings(CommandContext commandContext, List<WarnEntry> warnEntries) {
WarningsModel model = (WarningsModel) ContextConverter.slimFromCommandContext(commandContext, WarningsModel.class);
model.setWarnings(warnEntries);
Paginator paginator = paginatorService.createPaginatorFromTemplate(WARNINGS_RESPONSE_TEMPLATE, model, eventWaiter);
paginator.display(commandContext.getChannel());
return CommandResult.fromSuccess();
}
@Override
@@ -74,6 +86,7 @@ public class Warnings extends AbstractConditionableCommand {
.name("warnings")
.module(ModerationModule.MODERATION)
.templated(true)
.async(true)
.causesReaction(true)
.supportsEmbedException(true)
.parameters(parameters)

45
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/converter/UserNotesConverter.java
View File

@@ -1,15 +1,23 @@
package dev.sheldan.abstracto.moderation.converter;
import dev.sheldan.abstracto.core.models.FullUserInServer;
import dev.sheldan.abstracto.core.models.ServerSpecificId;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.utils.FutureUtils;
import dev.sheldan.abstracto.moderation.models.database.UserNote;
import dev.sheldan.abstracto.moderation.models.template.commands.NoteEntryModel;
import dev.sheldan.abstracto.moderation.service.management.UserNoteManagementService;
import net.dv8tion.jda.api.entities.Member;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.concurrent.CompletableFuture;
@Component
public class UserNotesConverter {
@@ -19,18 +27,45 @@ public class UserNotesConverter {
@Autowired
private BotService botService;
public List<NoteEntryModel> fromNotes(List<UserNote> userNotes){
List<NoteEntryModel> entryModels = new ArrayList<>();
@Autowired
private UserNotesConverter self;
@Autowired
private UserNoteManagementService userNoteManagementService;
public CompletableFuture<List<NoteEntryModel>> fromNotes(List<UserNote> userNotes){
List<CompletableFuture<Member>> memberFutures = new ArrayList<>();
HashMap<ServerSpecificId, CompletableFuture<Member>> noteMemberMap = new HashMap<>();
userNotes.forEach(userNote -> {
CompletableFuture<Member> memberFuture = botService.getMemberInServerAsync(userNote.getUser());
memberFutures.add(memberFuture);
noteMemberMap.put(userNote.getUserNoteId(), memberFuture);
});
if(userNotes.isEmpty()) {
memberFutures.add(CompletableFuture.completedFuture(null));
}
return FutureUtils.toSingleFutureGeneric(memberFutures).thenApply(aVoid ->
self.loadFullNotes(noteMemberMap)
);
}
@Transactional
public List<NoteEntryModel> loadFullNotes(Map<ServerSpecificId, CompletableFuture<Member>> futureHashMap) {
List<NoteEntryModel> entryModels = new ArrayList<>();
futureHashMap.keySet().forEach(serverSpecificId -> {
Member member = futureHashMap.get(serverSpecificId).join();
UserNote note = userNoteManagementService.loadNote(serverSpecificId.getId(), serverSpecificId.getServerId());
FullUserInServer fullUser = FullUserInServer
.builder()
.member(botService.getMemberInServer(userNote.getUser()))
.aUserInAServer(userNote.getUser())
.member(member)
.aUserInAServer(note.getUser())
.build();
NoteEntryModel entryModel = NoteEntryModel
.builder()
.note(note)
.fullUser(fullUser)
.note(userNote)
.build();
entryModels.add(entryModel);
});

55
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/converter/WarnEntryConverter.java
View File

@@ -1,14 +1,24 @@
package dev.sheldan.abstracto.moderation.converter;
import dev.sheldan.abstracto.core.models.FullUserInServer;
import dev.sheldan.abstracto.core.models.FutureMemberPair;
import dev.sheldan.abstracto.core.models.ServerSpecificId;
import dev.sheldan.abstracto.core.service.BotService;
import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
import dev.sheldan.abstracto.core.utils.FutureUtils;
import dev.sheldan.abstracto.moderation.models.database.Warning;
import dev.sheldan.abstracto.moderation.models.template.commands.WarnEntry;
import dev.sheldan.abstracto.moderation.service.management.WarnManagementService;
import net.dv8tion.jda.api.entities.Member;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.concurrent.CompletableFuture;
@Component
public class WarnEntryConverter {
@@ -16,25 +26,56 @@ public class WarnEntryConverter {
@Autowired
private BotService botService;
public List<WarnEntry> fromWarnings(List<Warning> warnings) {
List<WarnEntry> entries = new ArrayList<>();
@Autowired
private UserInServerManagementService userInServerManagementService;
@Autowired
private WarnManagementService warnManagementService;
@Autowired
private WarnEntryConverter self;
public CompletableFuture<List<WarnEntry>> fromWarnings(List<Warning> warnings) {
Map<ServerSpecificId, FutureMemberPair> loadedWarnings = new HashMap<>();
List<CompletableFuture<Member>> allFutures = new ArrayList<>();
// TODO maybe optimize to not need to look into the cache twice
warnings.forEach(warning -> {
CompletableFuture<Member> warningMemberFuture = botService.getMemberInServerAsync(warning.getWarningUser());
CompletableFuture<Member> warnedMemberFuture = botService.getMemberInServerAsync(warning.getWarnedUser());
FutureMemberPair futurePair = FutureMemberPair.builder().firstMember(warningMemberFuture).secondMember(warnedMemberFuture).build();
loadedWarnings.put(warning.getWarnId(), futurePair);
allFutures.add(warningMemberFuture);
allFutures.add(warnedMemberFuture);
});
return FutureUtils.toSingleFutureGeneric(allFutures).thenApply(aVoid ->
self.loadFullWarnEntries(loadedWarnings)
);
}
@Transactional
public List<WarnEntry> loadFullWarnEntries(Map<ServerSpecificId, FutureMemberPair> loadedWarnInfo) {
List<WarnEntry> entries = new ArrayList<>();
loadedWarnInfo.keySet().forEach(warning -> {
FutureMemberPair memberPair = loadedWarnInfo.get(warning);
Member warnedMember = memberPair.getSecondMember().join();
FullUserInServer warnedUser = FullUserInServer
.builder()
.member(botService.getMemberInServer(warning.getWarnedUser()))
.aUserInAServer(warning.getWarnedUser())
.member(warnedMember)
.aUserInAServer(userInServerManagementService.loadUser(warnedMember))
.build();
Member warningMember = memberPair.getFirstMember().join();
FullUserInServer warningUser = FullUserInServer
.builder()
.member(botService.getMemberInServer(warning.getWarningUser()))
.aUserInAServer(warning.getWarningUser())
.member(warningMember)
.aUserInAServer(userInServerManagementService.loadUser(warningMember))
.build();
WarnEntry entry = WarnEntry
.builder()
.warnedUser(warnedUser)
.warningUser(warningUser)
.warning(warning)
.warning(warnManagementService.findById(warning.getId(), warning.getServerId()))
.build();
entries.add(entry);
});

5
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/repository/UserNoteRepository.java
View File

@@ -20,8 +20,11 @@ public interface UserNoteRepository extends JpaRepository<UserNote, Long> {
List<UserNote> findByUser_ServerReference(AServer server);
@QueryHints(@QueryHint(name = org.hibernate.annotations.QueryHints.CACHEABLE, value = "true"))
boolean existsByUserNoteId_IdAndUserNoteId_ServerId(@NonNull Long aLong, Long serverId);
boolean existsByUserNoteId_IdAndUserNoteId_ServerId(@NonNull Long userNoteId, Long serverId);
void deleteByUserNoteId_IdAndUserNoteId_ServerId(@NonNull Long aLong, Long serverId);
@QueryHints(@QueryHint(name = org.hibernate.annotations.QueryHints.CACHEABLE, value = "true"))
UserNote findByUserNoteId_IdAndUserNoteId_ServerId(Long userNoteId, Long serverId);
}

2
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/BanServiceBean.java
View File

@@ -52,7 +52,7 @@ public class BanServiceBean implements BanService {
}
private CompletableFuture<Void> banUser(Long guildId, Long userId, String reason) {
Optional<Guild> guildByIdOptional = botService.getGuildById(guildId);
Optional<Guild> guildByIdOptional = botService.getGuildByIdOptional(guildId);
if(guildByIdOptional.isPresent()) {
return banUser(guildByIdOptional.get(), userId, reason);
} else {

53
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/MuteServiceBean.java
View File

@@ -39,6 +39,7 @@ import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
@@ -110,22 +111,6 @@ public class MuteServiceBean implements MuteService {
return muteUserInServer(mutedUser, mutingUser, reason, unMuteDate, message);
}
@Override
public CompletableFuture<Void> muteAUserInAServer(AUserInAServer userBeingMuted, AUserInAServer userMuting, String reason, Instant unMuteDate, ServerChannelMessage message) {
FullUserInServer mutedUser = FullUserInServer
.builder()
.aUserInAServer(userBeingMuted)
.member(botService.getMemberInServer(userBeingMuted))
.build();
FullUserInServer mutingUser = FullUserInServer
.builder()
.aUserInAServer(userMuting)
.member(botService.getMemberInServer(userMuting))
.build();
return muteUserInServer(mutedUser, mutingUser, reason, unMuteDate, message);
}
@Override
public CompletableFuture<Void> muteUserInServer(FullUserInServer userBeingMuted, FullUserInServer userMuting, String reason, Instant unMuteDate, ServerChannelMessage message) {
AServer serverBeingMutedIn = userBeingMuted.getAUserInAServer().getServerReference();
@@ -251,7 +236,7 @@ public class MuteServiceBean implements MuteService {
return FutureUtils.toSingleFutureGeneric(completableFutures);
}
private CompletableFuture<Void> sendUnMuteLog(UnMuteLog muteLogModel) {
private CompletableFuture<Void> sendUnMuteLogMessage(UnMuteLog muteLogModel) {
log.trace("Sending unMute log to the mute posttarget.");
MessageToSend message = templateService.renderEmbedTemplate(UN_MUTE_LOG_TEMPLATE, muteLogModel);
List<CompletableFuture<Message>> completableFutures = postTargetService.sendEmbedInPostTarget(message, MutingPostTarget.MUTE_LOG, muteLogModel.getServer().getId());
@@ -279,7 +264,7 @@ public class MuteServiceBean implements MuteService {
log.info("UnMuting {} in server {}", mute.getMutedUser().getUserReference().getId(), mutingServer.getId());
MuteRole muteRole = muteRoleManagementService.retrieveMuteRoleForServer(mutingServer);
log.trace("Using the mute role {} mapping to role {}", muteRole.getId(), muteRole.getRole().getId());
Guild guild = botService.getGuildByIdNullable(mutingServer.getId());
Guild guild = botService.getGuildById(mutingServer.getId());
CompletableFuture<Void> roleRemovalFuture;
if(botService.isUserInGuild(guild, mute.getMutedUser())) {
roleRemovalFuture = roleService.removeRoleFromUserFuture(mute.getMutedUser(), muteRole.getRole());
@@ -287,24 +272,40 @@ public class MuteServiceBean implements MuteService {
roleRemovalFuture = CompletableFuture.completedFuture(null);
log.info("User to unMute left the guild.");
}
Long serverId = mutingServer.getId();
CompletableFuture<Member> mutingMemberFuture = botService.getMemberInServerAsync(mute.getMutingUser());
CompletableFuture<Member> mutedMemberFuture = botService.getMemberInServerAsync(mute.getMutedUser());
CompletableFuture<Void> finalFuture = new CompletableFuture<>();
CompletableFuture.allOf(mutingMemberFuture, mutedMemberFuture, roleRemovalFuture, mutingMemberFuture, mutedMemberFuture).handle((aVoid, throwable) -> {
self.sendUnmuteLog(muteId, guild, mutingMemberFuture, mutedMemberFuture).thenAccept(aVoid1 ->
finalFuture.complete(null)
);
return null;
});
return finalFuture;
}
@Transactional
public CompletionStage<Void> sendUnmuteLog(Long muteId, Guild guild, CompletableFuture<Member> mutingMemberFuture, CompletableFuture<Member> mutedMemberFuture) {
Mute mute = muteManagementService.findMute(muteId, guild.getIdLong());
AServer mutingServer = serverManagementService.loadServer(guild.getIdLong());
UnMuteLog unMuteLog = UnMuteLog
.builder()
.mute(mute)
.mutingUser(botService.getMemberInServer(mute.getMutingUser()))
.unMutedUser(botService.getMemberInServer(mute.getMutedUser()))
.mutingUser(mutingMemberFuture.join())
.unMutedUser(mutedMemberFuture.join())
.guild(guild)
.server(mutingServer)
.build();
CompletableFuture<Void> notificationFuture = sendUnMuteLog(unMuteLog);
return CompletableFuture.allOf(roleRemovalFuture, notificationFuture).thenAccept(aVoid ->
self.endMuteInDatabase(muteId, serverId)
CompletableFuture<Void> notificationFuture = sendUnMuteLogMessage(unMuteLog);
return CompletableFuture.allOf(notificationFuture).thenAccept(aVoid ->
self.endMuteInDatabase(muteId, guild.getIdLong())
);
}
@Transactional
public void endMuteInDatabase(Long muteId, Long serverId) {
Optional<Mute> muteOptional = muteManagementService.findMute(muteId, serverId);
Optional<Mute> muteOptional = muteManagementService.findMuteOptional(muteId, serverId);
muteOptional.ifPresent(mute ->
completelyUnMuteUser(mute.getMutedUser())
);
@@ -315,7 +316,7 @@ public class MuteServiceBean implements MuteService {
@Transactional
public CompletableFuture<Void> endMute(Long muteId, Long serverId) {
log.info("UnMuting the mute {} in server {}", muteId, serverId);
Optional<Mute> muteOptional = muteManagementService.findMute(muteId, serverId);
Optional<Mute> muteOptional = muteManagementService.findMuteOptional(muteId, serverId);
if(muteOptional.isPresent()) {
return endMute(muteOptional.get());
} else {

46
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/WarnServiceBean.java
View File

@@ -1,5 +1,7 @@
package dev.sheldan.abstracto.moderation.service;
import dev.sheldan.abstracto.core.models.FutureMemberPair;
import dev.sheldan.abstracto.core.models.ServerSpecificId;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.*;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
@@ -19,7 +21,6 @@ import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.templating.service.TemplateService;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.entities.*;
import org.jetbrains.annotations.NotNull;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
@@ -27,9 +28,12 @@ import org.springframework.transaction.annotation.Transactional;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
@Slf4j
@Component
@@ -120,7 +124,6 @@ public class WarnServiceBean implements WarnService {
);
}
@NotNull
private List<Long> flattenWarnings(List<Warning> warningsToDecay) {
List<Long> warningIds = new ArrayList<>();
warningsToDecay.forEach(warning ->
@@ -134,7 +137,7 @@ public class WarnServiceBean implements WarnService {
Instant now = Instant.now();
log.info("Decaying {} warnings.", warningIds.size());
warningIds.forEach(warningId -> {
Optional<Warning> warningOptional = warnManagementService.findById(warningId, serverId);
Optional<Warning> warningOptional = warnManagementService.findByIdOptional(warningId, serverId);
warningOptional.ifPresent(warning ->
decayWarning(warning, now)
);
@@ -152,20 +155,47 @@ public class WarnServiceBean implements WarnService {
}
private CompletableFuture<Void> logDecayedWarnings(AServer server, List<Warning> warningsToDecay) {
log.trace("Logging decaying {} warnings in server {}.", warningsToDecay.size(), server.getId());
List<WarnDecayWarning> warnDecayWarnings = new ArrayList<>();
log.trace("Loading members decaying {} warnings in server {}.", warningsToDecay.size(), server.getId());
HashMap<ServerSpecificId, FutureMemberPair> warningMembers = new HashMap<>();
List<CompletableFuture<Member>> allFutures = new ArrayList<>();
Long serverId = server.getId();
warningsToDecay.forEach(warning -> {
CompletableFuture<Member> warningMember = botService.getMemberInServerAsync(warning.getWarningUser());
CompletableFuture<Member> warnedMember = botService.getMemberInServerAsync(warning.getWarnedUser());
FutureMemberPair futurePair = FutureMemberPair.builder().firstMember(warningMember).secondMember(warnedMember).build();
warningMembers.put(warning.getWarnId(), futurePair);
});
CompletableFuture<Void> sendingFuture = new CompletableFuture<>();
FutureUtils.toSingleFutureGeneric(allFutures).handle((aVoid, throwable) -> {
self.renderAndSendWarnDecayLogs(serverId, warningMembers).thenAccept(aVoid1 ->
sendingFuture.complete(null)
);
return null;
});
return sendingFuture;
}
@Transactional
public CompletionStage<Void> renderAndSendWarnDecayLogs(Long serverId, Map<ServerSpecificId, FutureMemberPair> warningMembers) {
AServer server = serverManagementService.loadServer(serverId);
List<WarnDecayWarning> warnDecayWarnings = new ArrayList<>();
warningMembers.keySet().forEach(serverSpecificId -> {
Warning warning = warnManagementService.findById(serverSpecificId.getId(), serverSpecificId.getServerId());
FutureMemberPair pair = warningMembers.get(serverSpecificId);
// TODO add ids to render in case any member left the server
WarnDecayWarning warnDecayWarning = WarnDecayWarning
.builder()
.warnedMember(botService.getMemberInServer(warning.getWarnedUser()))
.warningMember(botService.getMemberInServer(warning.getWarningUser()))
.warnedMember(pair.getFirstMember().join())
.warningMember(pair.getSecondMember().join())
.warning(warning)
.build();
warnDecayWarnings.add(warnDecayWarning);
});
WarnDecayLogModel warnDecayLogModel = WarnDecayLogModel
.builder()
.guild(botService.getGuildByIdNullable(server.getId()))
.guild(botService.getGuildById(server.getId()))
.server(server)
.warnings(warnDecayWarnings)
.build();

8
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/management/MuteManagementServiceBean.java
View File

@@ -1,5 +1,6 @@
package dev.sheldan.abstracto.moderation.service.management;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
import dev.sheldan.abstracto.core.models.AServerAChannelMessage;
import dev.sheldan.abstracto.core.models.ServerSpecificId;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
@@ -48,10 +49,15 @@ public class MuteManagementServiceBean implements MuteManagementService {
}
@Override
public Optional<Mute> findMute(Long muteId, Long serverId) {
public Optional<Mute> findMuteOptional(Long muteId, Long serverId) {
return muteRepository.findByMuteId_IdAndMuteId_ServerId(muteId, serverId);
}
@Override
public Mute findMute(Long muteId, Long serverId) {
return findMuteOptional(muteId, serverId).orElseThrow(() -> new AbstractoRunTimeException("Mute not found."));
}
@Override
public Mute saveMute(Mute mute) {
muteRepository.save(mute);

5
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/management/UserNoteManagementServiceBean.java
View File

@@ -46,6 +46,11 @@ public class UserNoteManagementServiceBean implements UserNoteManagementService
userNoteRepository.deleteByUserNoteId_IdAndUserNoteId_ServerId(id, server.getId());
}
@Override
public UserNote loadNote(Long userNoteId, Long serverId) {
return userNoteRepository.findByUserNoteId_IdAndUserNoteId_ServerId(userNoteId, serverId);
}
@Override
public boolean noteExists(Long id, AServer server) {
return userNoteRepository.existsByUserNoteId_IdAndUserNoteId_ServerId(id, server.getId());

10
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/service/management/WarnManagementServiceBean.java
View File

@@ -1,5 +1,6 @@
package dev.sheldan.abstracto.moderation.service.management;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
import dev.sheldan.abstracto.core.models.ServerSpecificId;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.moderation.models.database.Warning;
@@ -24,7 +25,7 @@ public class WarnManagementServiceBean implements WarnManagementService {
public Warning createWarning(AUserInAServer warnedAUser, AUserInAServer warningAUser, String reason, Long warnId) {
log.info("Creating warning with id {} for user {} in server {} cast by user {}.",
warnId, warnedAUser.getUserReference().getId(), warningAUser.getServerReference().getId(), warningAUser.getUserReference().getId());
ServerSpecificId warningId = new ServerSpecificId(warnId, warningAUser.getServerReference().getId());
ServerSpecificId warningId = new ServerSpecificId(warningAUser.getServerReference().getId(), warnId);
Warning warning = Warning.builder()
.reason(reason)
.warnedUser(warnedAUser)
@@ -64,10 +65,15 @@ public class WarnManagementServiceBean implements WarnManagementService {
}
@Override
public Optional<Warning> findById(Long id, Long serverId) {
public Optional<Warning> findByIdOptional(Long id, Long serverId) {
return warnRepository.findByWarnId_IdAndWarnId_ServerId(id, serverId);
}
@Override
public Warning findById(Long id, Long serverId) {
return findByIdOptional(id, serverId).orElseThrow(() -> new AbstractoRunTimeException("Warning not found."));
}
@Override
public void deleteWarning(Warning warning) {
log.info("Deleting warning with id {} in server {}.", warning.getWarnId().getId(), warning.getWarnId().getServerId());