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

update JDA and jda Utilities version

Browse Source 
fixed typos in the code
This commit is contained in:
Sheldan
2020-06-28 12:04:34 +02:00
parent c44eb80fc5
commit e8767429bf
40 changed files with 106 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/commands/mute/UnMute.java
View File

@@ -42,8 +42,8 @@ public class UnMute extends AbstractConditionableCommand {
return CommandResult.fromError(templateService.renderSimpleTemplate(NO_ACTIVE_MUTE));
}
Mute mute = muteManagementService.getAMuteOf(member);
muteService.unmuteUser(mute);
muteService.cancelUnmuteJob(mute);
muteService.unMuteUser(mute);
muteService.cancelUnMuteJob(mute);
muteService.completelyUnMuteMember(member);
return CommandResult.fromSuccess();
}

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

@@ -23,7 +23,7 @@ public class UnMuteJob extends QuartzJobBean {
@Override
protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
log.info("Executing unmute job for mute {}", muteId);
log.info("Executing unMute job for mute {}", muteId);
muteService.endMute(muteId);
}

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

@@ -79,11 +79,11 @@ public class MuteServiceBean implements MuteService {
private ChannelManagementService channelManagementService;
public static final String MUTE_LOG_TEMPLATE = "mute_log";
public static final String UNMUTE_LOG_TEMPLATE = "unmute_log";
public static final String UN_MUTE_LOG_TEMPLATE = "unmute_log";
public static final String MUTE_NOTIFICATION_TEMPLATE = "mute_notification";
@Override
public Mute muteMember(Member memberToMute, Member mutingMember, String reason, Instant unmuteDate, Message message) {
public Mute muteMember(Member memberToMute, Member mutingMember, String reason, Instant unMuteDate, Message message) {
FullUser mutedUser = FullUser
.builder()
.aUserInAServer(userInServerManagementService.loadUser(memberToMute))
@@ -95,11 +95,11 @@ public class MuteServiceBean implements MuteService {
.aUserInAServer(userInServerManagementService.loadUser(mutingMember))
.member(mutingMember)
.build();
return muteUser(mutedUser, mutingUser, reason, unmuteDate, message);
return muteUser(mutedUser, mutingUser, reason, unMuteDate, message);
}
@Override
public Mute muteAUserInAServer(AUserInAServer userBeingMuted, AUserInAServer userMuting, String reason, Instant unmuteDate, Message message) {
public Mute muteAUserInAServer(AUserInAServer userBeingMuted, AUserInAServer userMuting, String reason, Instant unMuteDate, Message message) {
FullUser mutedUser = FullUser
.builder()
.aUserInAServer(userBeingMuted)
@@ -111,11 +111,11 @@ public class MuteServiceBean implements MuteService {
.aUserInAServer(userMuting)
.member(botService.getMemberInServer(userMuting))
.build();
return muteUser(mutedUser, mutingUser, reason, unmuteDate, message);
return muteUser(mutedUser, mutingUser, reason, unMuteDate, message);
}
@Override
public Mute muteUser(FullUser userBeingMuted, FullUser userMuting, String reason, Instant unmuteDate, Message message) {
public Mute muteUser(FullUser userBeingMuted, FullUser userMuting, String reason, Instant unMuteDate, Message message) {
AServer serverBeingMutedIn = userBeingMuted.getAUserInAServer().getServerReference();
if(!muteRoleManagementService.muteRoleForServerExists(serverBeingMutedIn)) {
log.error("Mute role for server {} has not been setup.", serverBeingMutedIn.getId());
@@ -123,7 +123,7 @@ public class MuteServiceBean implements MuteService {
}
Member memberBeingMuted = userBeingMuted.getMember();
log.info("User {} mutes user {} until {}",
memberBeingMuted.getIdLong(), userMuting.getMember().getIdLong(), unmuteDate);
memberBeingMuted.getIdLong(), userMuting.getMember().getIdLong(), unMuteDate);
if(message != null) {
log.trace("because of message {} in channel {} in server {}", message.getId(), message.getChannel().getId(), message.getGuild().getId());
} else {
@@ -132,14 +132,14 @@ public class MuteServiceBean implements MuteService {
AUserInAServer userInServerBeingMuted = userBeingMuted.getAUserInAServer();
applyMuteRole(userInServerBeingMuted);
Mute mute = createMuteObject(userMuting, reason, unmuteDate, message, userInServerBeingMuted);
Mute mute = createMuteObject(userMuting, reason, unMuteDate, message, userInServerBeingMuted);
Guild guild = memberBeingMuted.getGuild();
if(memberBeingMuted.getVoiceState() != null && memberBeingMuted.getVoiceState().getChannel() != null) {
guild.kickVoiceMember(memberBeingMuted).queue();
}
sendMuteNotification(message, memberBeingMuted, mute, guild);
String triggerKey = startUnmuteJobFor(unmuteDate, mute);
String triggerKey = startUnMuteJobFor(unMuteDate, mute);
mute.setTriggerKey(triggerKey);
muteManagementService.saveMute(mute);
return mute;
@@ -153,7 +153,7 @@ public class MuteServiceBean implements MuteService {
messageService.sendMessageToUser(memberBeingMuted.getUser(), muteNotificationMessage, textChannel);
}
private Mute createMuteObject(FullUser userMuting, String reason, Instant unmuteDate, Message message, AUserInAServer userInServerBeingMuted) {
private Mute createMuteObject(FullUser userMuting, String reason, Instant unMuteDate, Message message, AUserInAServer userInServerBeingMuted) {
AServerAChannelMessage origin = null;
if(message != null) {
long channelId = message.getChannel().getIdLong();
@@ -166,7 +166,7 @@ public class MuteServiceBean implements MuteService {
.messageId(message.getIdLong())
.build();
}
return muteManagementService.createMute(userInServerBeingMuted, userMuting.getAUserInAServer(), reason, unmuteDate, origin);
return muteManagementService.createMute(userInServerBeingMuted, userMuting.getAUserInAServer(), reason, unMuteDate, origin);
}
@Override
@@ -176,10 +176,10 @@ public class MuteServiceBean implements MuteService {
}
@Override
public String startUnmuteJobFor(Instant unmuteDate, Mute mute) {
Duration muteDuration = Duration.between(Instant.now(), unmuteDate);
public String startUnMuteJobFor(Instant unMuteDate, Mute mute) {
Duration muteDuration = Duration.between(Instant.now(), unMuteDate);
if(muteDuration.getSeconds() < 60) {
log.trace("Directly scheduling the unmute, because it was below the threshold.");
log.trace("Directly scheduling the unMute, because it was below the threshold.");
unMuteScheduler.schedule(() -> {
try {
self.endMute(mute.getId());
@@ -189,24 +189,24 @@ public class MuteServiceBean implements MuteService {
}, muteDuration.toNanos(), TimeUnit.NANOSECONDS);
return null;
} else {
log.trace("Starting scheduled job to execute unmute.");
log.trace("Starting scheduled job to execute unMute.");
JobDataMap parameters = new JobDataMap();
parameters.putAsString("muteId", mute.getId());
return schedulerService.executeJobWithParametersOnce("unMuteJob", "moderation", parameters, Date.from(unmuteDate));
return schedulerService.executeJobWithParametersOnce("unMuteJob", "moderation", parameters, Date.from(unMuteDate));
}
}
@Override
public void cancelUnmuteJob(Mute mute) {
public void cancelUnMuteJob(Mute mute) {
if(mute.getTriggerKey() != null) {
schedulerService.stopTrigger(mute.getTriggerKey());
}
}
@Override
public void muteMemberWithLog(Member memberToMute, Member memberMuting, String reason, Instant unmuteDate, MuteLog muteLog, Message message) {
public void muteMemberWithLog(Member memberToMute, Member memberMuting, String reason, Instant unMuteDate, MuteLog muteLog, Message message) {
log.trace("Muting member with sending a mute log");
Mute mute = muteMember(memberToMute, memberMuting, reason, unmuteDate, message);
Mute mute = muteMember(memberToMute, memberMuting, reason, unMuteDate, message);
muteLog.setMute(mute);
sendMuteLog(muteLog);
}
@@ -217,28 +217,28 @@ public class MuteServiceBean implements MuteService {
postTargetService.sendEmbedInPostTarget(message, MutingPostTarget.MUTE_LOG, muteLogModel.getServer().getId());
}
private void sendUnmuteLog(UnMuteLog muteLogModel) {
log.trace("Sending unmute log to the mute posttarget");
MessageToSend message = templateService.renderEmbedTemplate(UNMUTE_LOG_TEMPLATE, muteLogModel);
private void sendUnMuteLog(UnMuteLog muteLogModel) {
log.trace("Sending unMute log to the mute posttarget");
MessageToSend message = templateService.renderEmbedTemplate(UN_MUTE_LOG_TEMPLATE, muteLogModel);
postTargetService.sendEmbedInPostTarget(message, MutingPostTarget.MUTE_LOG, muteLogModel.getServer().getId());
}
@Override
@Transactional
public void unmuteUser(Mute mute) {
public void unMuteUser(Mute mute) {
if(Boolean.TRUE.equals(mute.getMuteEnded())) {
log.info("Mute {} has ended already, user {} does not need to be unmuted anymore.", mute.getId(), mute.getMutedUser().getUserReference().getId());
log.info("Mute {} has ended already, user {} does not need to be unMuted anymore.", mute.getId(), mute.getMutedUser().getUserReference().getId());
return;
}
AServer mutingServer = mute.getMutingServer();
log.info("Unmuting {} in server {}", mute.getMutedUser().getUserReference().getId(), mutingServer.getId());
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(mute.getMutingServer().getId());
if(botService.isUserInGuild(guild, mute.getMutedUser())) {
roleService.removeRoleFromUser(mute.getMutedUser(), muteRole.getRole());
} else {
log.info("User to unmute left the guild.");
log.info("User to unMute left the guild.");
}
UnMuteLog unMuteLog = UnMuteLog
.builder()
@@ -248,7 +248,7 @@ public class MuteServiceBean implements MuteService {
.guild(guild)
.server(mute.getMutingServer())
.build();
sendUnmuteLog(unMuteLog);
sendUnMuteLog(unMuteLog);
mute.setMuteEnded(true);
muteManagementService.saveMute(mute);
}
@@ -256,9 +256,9 @@ public class MuteServiceBean implements MuteService {
@Override
@Transactional
public void endMute(Long muteId) {
log.info("Unmuting the mute {}", muteId);
log.info("UnMuting the mute {}", muteId);
Optional<Mute> mute = muteManagementService.findMute(muteId);
mute.ifPresent(this::unmuteUser);
mute.ifPresent(this::unMuteUser);
}
@Override
@@ -266,7 +266,7 @@ public class MuteServiceBean implements MuteService {
List<Mute> allMutesOfUser = muteManagementService.getAllMutesOf(aUserInAServer);
allMutesOfUser.forEach(mute -> {
mute.setMuteEnded(true);
cancelUnmuteJob(mute);
cancelUnMuteJob(mute);
muteManagementService.saveMute(mute);
});
}

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

@@ -25,14 +25,14 @@ public class MuteManagementServiceBean implements MuteManagementService {
private UserInServerManagementService userInServerManagementService;
@Override
public Mute createMute(AUserInAServer mutedUser, AUserInAServer mutingUser, String reason, Instant unmuteDate, AServerAChannelMessage muteMessage) {
public Mute createMute(AUserInAServer mutedUser, AUserInAServer mutingUser, String reason, Instant unMuteDate, AServerAChannelMessage muteMessage) {
log.trace("Creating mute for user {} executed by user {} in server {}, user will be un-muted at {}",
mutedUser.getUserReference().getId(), mutingUser.getUserReference().getId(), mutedUser.getServerReference().getId(), unmuteDate);
mutedUser.getUserReference().getId(), mutingUser.getUserReference().getId(), mutedUser.getServerReference().getId(), unMuteDate);
Mute mute = Mute
.builder()
.mutedUser(mutedUser)
.mutingUser(mutingUser)
.muteTargetDate(unmuteDate)
.muteTargetDate(unMuteDate)
.mutingServer(mutedUser.getServerReference())
.mutingChannel(muteMessage.getChannel())
.messageId(muteMessage.getMessageId())

4
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/commands/mute/UnMuteTest.java
View File

@@ -49,8 +49,8 @@ public class UnMuteTest {
Mute mute = Mute.builder().build();
when(muteManagementService.getAMuteOf(memberToUnMute)).thenReturn(mute);
CommandResult result = testUnit.execute(parameters);
verify(muteService, times(1)).unmuteUser(mute);
verify(muteService, times(1)).cancelUnmuteJob(mute);
verify(muteService, times(1)).unMuteUser(mute);
verify(muteService, times(1)).cancelUnMuteJob(mute);
verify(muteService, times(1)).completelyUnMuteMember(memberToUnMute);
CommandTestUtilities.checkSuccessfulCompletion(result);
}

10
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/MuteServiceBeanTest.java
View File

@@ -185,14 +185,14 @@ public class MuteServiceBeanTest {
@Test
public void testCancelUnMuteJob() {
Mute mute = Mute.builder().triggerKey(TRIGGER).build();
testUnit.cancelUnmuteJob(mute);
testUnit.cancelUnMuteJob(mute);
verify(schedulerService, times(1)).stopTrigger(TRIGGER);
}
@Test
public void testCancelNotExistingJob() {
Mute mute = Mute.builder().build();
testUnit.cancelUnmuteJob(mute);
testUnit.cancelUnMuteJob(mute);
verify(schedulerService, times(0)).stopTrigger(anyString());
}
@@ -235,7 +235,7 @@ public class MuteServiceBeanTest {
Mute mute = Mockito.mock(Mute.class);
when(mute.getMuteEnded()).thenReturn(true);
when(mute.getMutedUser()).thenReturn(userBeingMuted);
testUnit.unmuteUser(mute);
testUnit.unMuteUser(mute);
verifyNoUnMuteHappened();
}
@@ -319,7 +319,7 @@ public class MuteServiceBeanTest {
when(mute.getMutingServer()).thenReturn(server);
setupUnMuteMocks(stillInGuild);
testUnit.unmuteUser(mute);
testUnit.unMuteUser(mute);
verifyUnMute(roleRemovals);
}
@@ -329,7 +329,7 @@ public class MuteServiceBeanTest {
when(botService.getGuildByIdNullable(server.getId())).thenReturn(guild);
when(botService.isUserInGuild(guild, userBeingMuted)).thenReturn(stillInGuild);
when(botService.getMemberInServer(userBeingMuted)).thenReturn(memberBeingMuted);
when(templateService.renderEmbedTemplate(eq(MuteServiceBean.UNMUTE_LOG_TEMPLATE), any(UnMuteLog.class))).thenReturn(messageToSend);
when(templateService.renderEmbedTemplate(eq(MuteServiceBean.UN_MUTE_LOG_TEMPLATE), any(UnMuteLog.class))).thenReturn(messageToSend);
}
private void verifyUnMute(int roleRemovals) {