Sheldan/abstracto
1
0
Fork 0
mirror of https://github.com/Sheldan/abstracto.git synced 2026-06-15 23:16:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

[AB-215] adding create alias and delete alias commands to create service specific aliases for commands

Browse Source 
renaming package in commands package
defaulting to latest in docker compose build for deployment container
fixing jacoco configuration
changing that if there are no parameters required, parameters are accepted
This commit is contained in:
Sheldan
2021-03-27 13:17:27 +01:00
parent a494d4d2f2
commit 9541f907b8
135 changed files with 1904 additions and 376 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/command/RollTest.java
View File

@@ -49,7 +49,7 @@ public class RollTest {
Long serverId = 3L;
Integer max = 10;
when(noParameters.getGuild().getIdLong()).thenReturn(serverId);
when(configService.getLongValue(ROLL_DEFAULT_HIGH_KEY, serverId)).thenReturn(max.longValue());
when(configService.getLongValueOrConfigDefault(ROLL_DEFAULT_HIGH_KEY, serverId)).thenReturn(max.longValue());
when(entertainmentService.calculateRollResult(1, max)).thenReturn(result);
when(channelService.sendEmbedTemplateInTextChannelList(eq(Roll.ROLL_RESPONSE_TEMPLATE_KEY), responseModelArgumentCaptor.capture(), eq(noParameters.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());
CompletableFuture<CommandResult> futureResult = testUnit.executeAsync(noParameters);

2
abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/test/java/dev/sheldan/abstracto/entertainment/service/EntertainmentServiceBeanTest.java
View File

@@ -79,7 +79,7 @@ public class EntertainmentServiceBeanTest {
when(guild.getIdLong()).thenReturn(serverId);
when(member.getGuild()).thenReturn(guild);
Long sides = 6L;
when(configService.getLongValue(EntertainmentFeatureConfig.ROULETTE_BULLETS_CONFIG_KEY, serverId)).thenReturn(sides);
when(configService.getLongValueOrConfigDefault(EntertainmentFeatureConfig.ROULETTE_BULLETS_CONFIG_KEY, serverId)).thenReturn(sides);
when(secureRandom.nextInt(sides.intValue())).thenReturn(randomValue);
boolean shot = testUnit.executeRoulette(member);
Assert.assertEquals(randomValue == 0, shot);

3
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/listener/JoiningUserRoleListener.java
View File

@@ -37,11 +37,10 @@ public class JoiningUserRoleListener implements AsyncJoinListener {
public DefaultListenerResult execute(MemberJoinModel model) {
AUserInAServer userInAServer = userInServerManagementService.loadOrCreateUser(model.getServerId(), model.getJoiningUser().getUserId());
AUserExperience userExperience = userExperienceManagementService.findUserInServer(userInAServer);
Long userInServerId = userInAServer.getUserInServerId();
if(userExperience != null) {
log.info("User {} joined {} with previous experience. Setting up experience role again (if necessary).", model.getJoiningUser().getUserId(), model.getServerId());
userExperienceService.syncForSingleUser(userExperience).thenAccept(result ->
log.info("Finished re-assigning experience for re-joining user {} in server {}.", userInServerId, model.getServerId())
log.info("Finished re-assigning experience for re-joining user {} in server {}.", model.getJoiningUser().getUserId(), model.getServerId())
);
} else {
log.info("Joined user {} in server {} does not have any previous experience. Not setting up anything.", model.getJoiningUser().getUserId(), model.getServerId());

8
abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/listener/JoiningUserRoleListenerTest.java
View File

@@ -1,5 +1,7 @@
package dev.sheldan.abstracto.experience.listener;
import dev.sheldan.abstracto.core.listener.DefaultListenerResult;
import dev.sheldan.abstracto.core.listener.ListenerExecutionResult;
import dev.sheldan.abstracto.core.models.ServerUser;
import dev.sheldan.abstracto.core.models.database.AUserInAServer;
import dev.sheldan.abstracto.core.models.listener.MemberJoinModel;
@@ -7,6 +9,7 @@ import dev.sheldan.abstracto.core.service.management.UserInServerManagementServi
import dev.sheldan.abstracto.experience.model.database.AUserExperience;
import dev.sheldan.abstracto.experience.service.AUserExperienceService;
import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -48,9 +51,9 @@ public class JoiningUserRoleListenerTest {
@Before
public void setup() {
when(serverUser.getServerId()).thenReturn(SERVER_ID);
when(serverUser.getUserId()).thenReturn(USER_ID);
when(model.getJoiningUser()).thenReturn(serverUser);
when(model.getServerId()).thenReturn(SERVER_ID);
when(userInServerManagementService.loadOrCreateUser(SERVER_ID, USER_ID)).thenReturn(aUserInAServer);
}
@@ -59,7 +62,8 @@ public class JoiningUserRoleListenerTest {
AUserExperience experience = Mockito.mock(AUserExperience.class);
when(userExperienceManagementService.findUserInServer(aUserInAServer)).thenReturn(experience);
when(userExperienceService.syncForSingleUser(experience)).thenReturn(CompletableFuture.completedFuture(null));
testUnit.execute(model);
DefaultListenerResult result = testUnit.execute(model);
Assert.assertEquals(DefaultListenerResult.PROCESSED, result);
}
@Test

3
abstracto-application/abstracto-modules/link-embed/link-embed-impl/src/test/java/dev/sheldan/abstracto/linkembed/service/management/MessageEmbedPostManagementServiceBeanTest.java
View File

@@ -59,7 +59,6 @@ public class MessageEmbedPostManagementServiceBeanTest {
AUserInAServer embeddedUser = Mockito.mock(AUserInAServer.class);
AChannel channel = Mockito.mock(AChannel.class);
AServer server = Mockito.mock(AServer.class);
when(server.getId()).thenReturn(SERVER_ID);
when(serverManagementService.loadOrCreate(SERVER_ID)).thenReturn(server);
when(channelManagementService.loadChannel(EMBEDDING_CHANNEL_ID)).thenReturn(channel);
CachedMessage cachedMessage = Mockito.mock(CachedMessage.class);
@@ -69,7 +68,6 @@ public class MessageEmbedPostManagementServiceBeanTest {
CachedAuthor cachedAuthor = Mockito.mock(CachedAuthor.class);
when(cachedAuthor.getAuthorId()).thenReturn(EMBEDDED_USER_ID);
when(cachedMessage.getAuthor()).thenReturn(cachedAuthor);
when(cachedMessage.getServerId()).thenReturn(SERVER_ID);
Message embeddingMessage = Mockito.mock(Message.class);
MessageChannel embeddingChannel = Mockito.mock(MessageChannel.class);
when(embeddingChannel.getIdLong()).thenReturn(EMBEDDING_CHANNEL_ID);
@@ -99,7 +97,6 @@ public class MessageEmbedPostManagementServiceBeanTest {
public void testToCreateEmbedForDifferentServers() {
Long originServerId = 4L;
AServer originalServer = Mockito.mock(AServer.class);
when(originalServer.getId()).thenReturn(originServerId);
AServer embeddingServer = Mockito.mock(AServer.class);
when(embeddingServer.getId()).thenReturn(SERVER_ID);
AUserInAServer embeddingUser = Mockito.mock(AUserInAServer.class);

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

@@ -51,7 +51,7 @@ public class LeaveLogger implements AsyncLeaveListener {
@Override
public DefaultListenerResult execute(MemberLeaveModel model) {
String text = templateService.renderTemplateWithMap(USER_LEAVE_TEMPLATE, getUserParameter(model.getMember().getUser()), model.getLeavingUser().getServerId());
String text = templateService.renderTemplateWithMap(USER_LEAVE_TEMPLATE, getUserParameter(model.getMember().getUser()), model.getServerId());
postTargetService.sendTextInPostTarget(text, LoggingPostTarget.LEAVE_LOG, model.getServerId());
return DefaultListenerResult.PROCESSED;
}

6
abstracto-application/abstracto-modules/moderation/moderation-impl/src/main/java/dev/sheldan/abstracto/moderation/listener/MessageEditedListener.java
View File

@@ -45,7 +45,7 @@ public class MessageEditedListener implements AsyncMessageTextUpdatedListener {
log.trace("Message content was the same. Possible reason was: message was not in cache.");
return DefaultListenerResult.IGNORED;
}
log.trace("Message {} in channel {} in guild {} was edited.", messageBefore.getMessageId(), messageBefore.getChannelId(), messageBefore.getServerId());
log.trace("Message {} in channel {} in guild {} was edited.", messageBefore.getMessageId(), messageBefore.getChannelId(), model.getServerId());
TextChannel textChannel = channelService.getTextChannelFromServer(model.getServerId(), messageBefore.getChannelId());
MessageEditedLog log = MessageEditedLog
.builder()
@@ -55,8 +55,8 @@ public class MessageEditedListener implements AsyncMessageTextUpdatedListener {
.guild(textChannel.getGuild())
.member(messageAfter.getMember())
.build();
MessageToSend message = templateService.renderEmbedTemplate(MESSAGE_EDITED_TEMPLATE, log, messageBefore.getServerId());
postTargetService.sendEmbedInPostTarget(message, LoggingPostTarget.EDIT_LOG, messageBefore.getServerId());
MessageToSend message = templateService.renderEmbedTemplate(MESSAGE_EDITED_TEMPLATE, log, model.getServerId());
postTargetService.sendEmbedInPostTarget(message, LoggingPostTarget.EDIT_LOG, model.getServerId());
return DefaultListenerResult.PROCESSED;
}

7
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/JoinLoggerTest.java
View File

@@ -49,14 +49,11 @@ public class JoinLoggerTest {
@Test
public void testExecute() {
when(serverUser.getUserId()).thenReturn(USER_ID);
when(serverUser.getServerId()).thenReturn(SERVER_ID);
when(model.getMember()).thenReturn(member);
when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(member));
testUnit.execute(model);
when(serverUser.getServerId()).thenReturn(SERVER_ID);
when(model.getServerId()).thenReturn(SERVER_ID);
String message = "text";
when(templateService.renderTemplateWithMap(eq(JoinLogger.USER_JOIN_TEMPLATE), any(), eq(SERVER_ID))).thenReturn(message);
testUnit.execute(model);
verify(postTargetService, times(1)).sendTextInPostTarget(message, LoggingPostTarget.JOIN_LOG, SERVER_ID);
}

14
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/JoinMuteListenerTest.java
View File

@@ -31,12 +31,6 @@ public class JoinMuteListenerTest {
@Mock
private UserInServerManagementService userInServerManagementService;
@Mock
private Member member;
@Mock
private Guild guild;
@Mock
private AUserInAServer joiningUser;
@@ -51,22 +45,22 @@ public class JoinMuteListenerTest {
@Test
public void testNonMutedUserJoins() {
when(serverUser.getServerId()).thenReturn(SERVER_ID);
when(serverUser.getUserId()).thenReturn(USER_ID);
when(userInServerManagementService.loadOrCreateUser(SERVER_ID, USER_ID)).thenReturn(joiningUser);
when(muteManagementService.hasActiveMute(joiningUser)).thenReturn(false);
when(model.getMember()).thenReturn(member);
when(model.getServerId()).thenReturn(SERVER_ID);
when(model.getJoiningUser()).thenReturn(serverUser);
testUnit.execute(model);
verify(muteService, times(0)).applyMuteRole(joiningUser);
}
@Test
public void testMutedUserJoins() {
when(serverUser.getServerId()).thenReturn(SERVER_ID);
when(model.getServerId()).thenReturn(SERVER_ID);
when(serverUser.getUserId()).thenReturn(USER_ID);
when(userInServerManagementService.loadOrCreateUser(SERVER_ID, USER_ID)).thenReturn(joiningUser);
when(muteManagementService.hasActiveMute(joiningUser)).thenReturn(true);
when(model.getMember()).thenReturn(member);
when(model.getJoiningUser()).thenReturn(serverUser);
testUnit.execute(model);
verify(muteService, times(1)).applyMuteRole(joiningUser);
}

5
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/LeaveLoggerTest.java
View File

@@ -51,14 +51,11 @@ public class LeaveLoggerTest {
@Test
public void testExecute() {
when(leavingUser.getUserId()).thenReturn(USER_ID);
when(leavingUser.getServerId()).thenReturn(SERVER_ID);
when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(member));
when(model.getServerId()).thenReturn(SERVER_ID);
when(model.getMember()).thenReturn(member);
User user = Mockito.mock(User.class);
when(member.getUser()).thenReturn(user);
String message = "text";
when(leavingUser.getServerId()).thenReturn(SERVER_ID);
when(templateService.renderTemplateWithMap(eq(LeaveLogger.USER_LEAVE_TEMPLATE), any(), eq(SERVER_ID))).thenReturn(message);
testUnit.execute(model);
verify(postTargetService, times(1)).sendTextInPostTarget(message, LoggingPostTarget.LEAVE_LOG, SERVER_ID);

1
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/MessageDeleteLogListenerTest.java
View File

@@ -94,7 +94,6 @@ public class MessageDeleteLogListenerTest {
public void testExecuteListener() {
when(deletedMessage.getAuthor()).thenReturn(cachedAuthor);
when(cachedAuthor.getAuthorId()).thenReturn(AUTHOR_ID);
when(deletedMessage.getServerId()).thenReturn(SERVER_ID);
when(memberService.getMemberInServerAsync(SERVER_ID, AUTHOR_ID)).thenReturn(CompletableFuture.completedFuture(member));
when(model.getCachedMessage()).thenReturn(deletedMessage);
when(model.getServerId()).thenReturn(SERVER_ID);

8
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/listener/MessageEditedListenerTest.java
View File

@@ -51,6 +51,7 @@ public class MessageEditedListenerTest {
@Mock
private CachedMessage messageBefore;
@Mock
private MessageTextUpdatedModel model;
private static final Long SERVER_ID = 4L;
@@ -77,17 +78,16 @@ public class MessageEditedListenerTest {
Guild guild = Mockito.mock(Guild.class);
when(channel.getGuild()).thenReturn(guild);
Member author = Mockito.mock(Member.class);
CachedAuthor cachedAuthor = Mockito.mock(CachedAuthor.class);
when(cachedAuthor.getAuthorId()).thenReturn(AUTHOR_ID);
when(messageBefore.getContent()).thenReturn(content);
when(messageBefore.getServerId()).thenReturn(SERVER_ID);
when(messageBefore.getChannelId()).thenReturn(CHANNEL_ID);
MessageToSend messageToSend = Mockito.mock(MessageToSend.class);
ArgumentCaptor<MessageEditedLog> captor = ArgumentCaptor.forClass(MessageEditedLog.class);
when(templateService.renderEmbedTemplate(eq(MessageEditedListener.MESSAGE_EDITED_TEMPLATE), captor.capture(), eq(SERVER_ID))).thenReturn(messageToSend);
when(memberService.getMemberInServerAsync(SERVER_ID, AUTHOR_ID)).thenReturn(CompletableFuture.completedFuture(author));
when(channelService.getTextChannelFromServer(SERVER_ID, CHANNEL_ID)).thenReturn(channel);
when(model.getAfter()).thenReturn(messageAfter);
when(model.getBefore()).thenReturn(messageBefore);
when(messageAfter.getMember()).thenReturn(author);
when(model.getServerId()).thenReturn(SERVER_ID);
testUnit.execute(model);
verify(postTargetService, times(1)).sendEmbedInPostTarget(messageToSend, LoggingPostTarget.EDIT_LOG, SERVER_ID);
MessageEditedLog capturedValue = captor.getValue();

22
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/management/MuteRoleManagementServiceBeanTest.java
View File

@@ -7,6 +7,7 @@ import dev.sheldan.abstracto.moderation.repository.MuteRoleRepository;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
@@ -46,8 +47,12 @@ public class MuteRoleManagementServiceBeanTest {
@Test
public void testCreateMuteRoleForServer() {
ARole role = Mockito.mock(ARole.class);
ArgumentCaptor<MuteRole> muteRoleCaptor = ArgumentCaptor.forClass(MuteRole.class);
MuteRole savedRole = Mockito.mock(MuteRole.class);
when(muteRoleRepository.save(muteRoleCaptor.capture())).thenReturn(savedRole);
MuteRole muteRoleForServer = testUnit.createMuteRoleForServer(server, role);
verifyRoleSaved(role, muteRoleForServer, 1);
Assert.assertEquals(savedRole, muteRoleForServer);
Assert.assertEquals(role, muteRoleCaptor.getValue().getRole());
}
@Test
@@ -67,8 +72,12 @@ public class MuteRoleManagementServiceBeanTest {
public void testSetMuteRoleWithoutPrevious() {
ARole role = Mockito.mock(ARole.class);
when(muteRoleRepository.existsByRoleServer(server)).thenReturn(false);
ArgumentCaptor<MuteRole> muteRoleCaptor = ArgumentCaptor.forClass(MuteRole.class);
MuteRole savedRole = Mockito.mock(MuteRole.class);
when(muteRoleRepository.save(muteRoleCaptor.capture())).thenReturn(savedRole);
MuteRole muteRole = testUnit.setMuteRoleForServer(server, role);
verifyRoleSaved(role, muteRole, 1);
Assert.assertEquals(savedRole, muteRole);
Assert.assertEquals(role, muteRoleCaptor.getValue().getRole());
}
@Test
@@ -76,16 +85,11 @@ public class MuteRoleManagementServiceBeanTest {
ARole role = Mockito.mock(ARole.class);
when(muteRoleRepository.existsByRoleServer(server)).thenReturn(true);
MuteRole existingRole = Mockito.mock(MuteRole.class);
when(existingRole.getRole()).thenReturn(role);
when(muteRoleRepository.findByRoleServer(server)).thenReturn(existingRole);
MuteRole muteRole = testUnit.setMuteRoleForServer(server, role);
verifyRoleSaved(role, muteRole, 0);
testUnit.setMuteRoleForServer(server, role);
verify(existingRole, times(1)).setRole(role);
}
private void verifyRoleSaved(ARole role, MuteRole muteRoleForServer, Integer saveCount) {
Assert.assertEquals(role, muteRoleForServer.getRole());
verify(muteRoleRepository, times(saveCount)).save(muteRoleForServer);
}
}

11
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/management/UserNoteManagementServiceBeanTest.java
View File

@@ -9,6 +9,7 @@ import dev.sheldan.abstracto.moderation.repository.UserNoteRepository;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
@@ -46,10 +47,14 @@ public class UserNoteManagementServiceBeanTest {
AUser user = Mockito.mock(AUser.class);
when(userInAServer.getUserReference()).thenReturn(user);
when(userInAServer.getServerReference()).thenReturn(server);
UserNote savedNote = Mockito.mock(UserNote.class);
ArgumentCaptor<UserNote> noteCaptor = ArgumentCaptor.forClass(UserNote.class);
when(userNoteRepository.save(noteCaptor.capture())).thenReturn(savedNote);
UserNote userNote = testUnit.createUserNote(userInAServer, NOTE_TEXT);
verify(userNoteRepository, times(1)).save(userNote);
Assert.assertEquals(userInAServer, userNote.getUser());
Assert.assertEquals(NOTE_TEXT, userNote.getNote());
Assert.assertEquals(savedNote, userNote);
UserNote capturedNote = noteCaptor.getValue();
Assert.assertEquals(userInAServer, capturedNote.getUser());
Assert.assertEquals(NOTE_TEXT, capturedNote.getNote());
}
@Test

15
abstracto-application/abstracto-modules/moderation/moderation-impl/src/test/java/dev/sheldan/abstracto/moderation/service/management/WarnManagementServiceBeanTest.java
View File

@@ -9,6 +9,7 @@ import dev.sheldan.abstracto.moderation.repository.WarnRepository;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
@@ -47,12 +48,16 @@ public class WarnManagementServiceBeanTest {
when(warningUser.getUserReference()).thenReturn(user);
when(warnedUser.getUserReference()).thenReturn(user);
String reason = "REASON";
ArgumentCaptor<Warning> warningArgumentCaptor = ArgumentCaptor.forClass(Warning.class);
Warning savedWarning = Mockito.mock(Warning.class);
when(warnRepository.save(warningArgumentCaptor.capture())).thenReturn(savedWarning);
Warning warning = testUnit.createWarning(warnedUser, warningUser, reason, 8L);
Assert.assertEquals(warningUser, warning.getWarningUser());
Assert.assertEquals(warnedUser, warning.getWarnedUser());
Assert.assertEquals(reason, warning.getReason());
Assert.assertFalse(warning.getDecayed());
verify(warnRepository, times(1)).save(warning);
Assert.assertEquals(savedWarning, warning);
Warning capturedWarning = warningArgumentCaptor.getValue();
Assert.assertEquals(warningUser, capturedWarning.getWarningUser());
Assert.assertEquals(warnedUser, capturedWarning.getWarnedUser());
Assert.assertEquals(reason, capturedWarning.getReason());
Assert.assertFalse(capturedWarning.getDecayed());
}
@Test

4
abstracto-application/abstracto-modules/modmail/modmail-impl/src/test/java/dev/sheldan/abstracto/modmail/listener/ModMailMessageDeletedListenerTest.java
View File

@@ -83,7 +83,6 @@ public class ModMailMessageDeletedListenerTest {
@Test
public void testDeleteNonDuplicatedMessage() {
when(deletedMessage.getMessageId()).thenReturn(DELETED_MESSAGE_ID);
when(deletedMessage.getServerId()).thenReturn(SERVER_ID);
when(modMailMessageManagementService.getByMessageIdOptional(DELETED_MESSAGE_ID)).thenReturn(Optional.of(modMailMessage));
ModMailThread thread = Mockito.mock(ModMailThread.class);
AUserInAServer targetUsInAServer = Mockito.mock(AUserInAServer.class);
@@ -100,6 +99,7 @@ public class ModMailMessageDeletedListenerTest {
when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(targetMember));
when(messageService.deleteMessageInChannelWithUser(targetUser, CREATED_MESSAGE_ID_2)).thenReturn(CompletableFuture.completedFuture(null));
when(model.getCachedMessage()).thenReturn(deletedMessage);
when(model.getServerId()).thenReturn(SERVER_ID);
testUnit.execute(model);
verify(messageService, times(0)).deleteMessageInChannelInServer(eq(SERVER_ID), anyLong(), any());
verify(self, times(1)).removeMessageFromThread(DELETED_MESSAGE_ID);
@@ -108,7 +108,6 @@ public class ModMailMessageDeletedListenerTest {
@Test
public void testDeleteDuplicatedMessage() {
when(deletedMessage.getMessageId()).thenReturn(DELETED_MESSAGE_ID);
when(deletedMessage.getServerId()).thenReturn(SERVER_ID);
when(modMailMessageManagementService.getByMessageIdOptional(DELETED_MESSAGE_ID)).thenReturn(Optional.of(modMailMessage));
ModMailThread thread = Mockito.mock(ModMailThread.class);
AUserInAServer targetUsInAServer = Mockito.mock(AUserInAServer.class);
@@ -127,6 +126,7 @@ public class ModMailMessageDeletedListenerTest {
when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(targetMember));
when(messageService.deleteMessageInChannelWithUser(targetUser, CREATED_MESSAGE_ID_2)).thenReturn(CompletableFuture.completedFuture(null));
when(messageService.deleteMessageInChannelInServer(SERVER_ID, CHANNEL_ID, CREATED_MESSAGE_ID_1)).thenReturn(CompletableFuture.completedFuture(null));
when(model.getServerId()).thenReturn(SERVER_ID);
when(model.getCachedMessage()).thenReturn(deletedMessage);
testUnit.execute(model);
verify(self, times(1)).removeMessageFromThread(DELETED_MESSAGE_ID);

21
abstracto-application/abstracto-modules/remind/remind-impl/src/test/java/dev/sheldan/abstracto/remind/service/management/ReminderManagementServiceBeanTest.java
View File

@@ -10,6 +10,7 @@ import dev.sheldan.abstracto.remind.repository.ReminderRepository;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
@@ -56,15 +57,19 @@ public class ReminderManagementServiceBeanTest {
String reminderText = "text";
Instant reminderTargetDate = Instant.ofEpochSecond(1590615937);
Long messageId = 5L;
ArgumentCaptor<Reminder> reminderArgumentCaptor = ArgumentCaptor.forClass(Reminder.class);
Reminder savedReminder = Mockito.mock(Reminder.class);
when(reminderRepository.save(reminderArgumentCaptor.capture())).thenReturn(savedReminder);
Reminder createdReminder = testUnit.createReminder(serverAChannelAUser, reminderText, reminderTargetDate, messageId);
Assert.assertEquals(messageId, createdReminder.getMessageId());
Assert.assertEquals(aUserInAServer, createdReminder.getRemindedUser());
Assert.assertEquals(server, createdReminder.getServer());
Assert.assertEquals(reminderText, createdReminder.getText());
Assert.assertEquals(reminderTargetDate, createdReminder.getTargetDate());
Assert.assertEquals(channel, createdReminder.getChannel());
Assert.assertFalse(createdReminder.isReminded());
verify(reminderRepository, times(1)).save(createdReminder);
Assert.assertEquals(savedReminder, createdReminder);
Reminder capturedReminder = reminderArgumentCaptor.getValue();
Assert.assertEquals(messageId, capturedReminder.getMessageId());
Assert.assertEquals(aUserInAServer, capturedReminder.getRemindedUser());
Assert.assertEquals(server, capturedReminder.getServer());
Assert.assertEquals(reminderText, capturedReminder.getText());
Assert.assertEquals(reminderTargetDate, capturedReminder.getTargetDate());
Assert.assertEquals(channel, capturedReminder.getChannel());
Assert.assertFalse(capturedReminder.isReminded());
}
@Test

13
abstracto-application/abstracto-modules/repost-detection/repost-detection-impl/src/test/java/dev/sheldan/abstracto/repostdetection/service/management/PostedImageManagementBeanTest.java
View File

@@ -12,6 +12,7 @@ import dev.sheldan.abstracto.repostdetection.service.RepostServiceBean;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
@@ -55,11 +56,15 @@ public class PostedImageManagementBeanTest {
when(serverAChannelAUser.getGuild()).thenReturn(server);
when(serverAChannelAUser.getChannel()).thenReturn(channel);
when(serverAChannelAUser.getAUserInAServer()).thenReturn(aUserInAServer);
ArgumentCaptor<PostedImage> postedImageArgumentCaptor = ArgumentCaptor.forClass(PostedImage.class);
PostedImage savedPost = Mockito.mock(PostedImage.class);
when(postedImageRepository.save(postedImageArgumentCaptor.capture())).thenReturn(savedPost);
PostedImage createdPost = testUnit.createPost(serverAChannelAUser, MESSAGE_ID, HASH, INDEX);
Assert.assertEquals(HASH, createdPost.getImageHash());
Assert.assertEquals(INDEX, createdPost.getPostId().getPosition());
Assert.assertEquals(MESSAGE_ID, createdPost.getPostId().getMessageId());
verify(postedImageRepository, times(1)).save(createdPost);
Assert.assertEquals(savedPost, createdPost);
PostedImage capturedPost = postedImageArgumentCaptor.getValue();
Assert.assertEquals(HASH, capturedPost.getImageHash());
Assert.assertEquals(INDEX, capturedPost.getPostId().getPosition());
Assert.assertEquals(MESSAGE_ID, capturedPost.getPostId().getMessageId());
}
@Test

17
abstracto-application/abstracto-modules/repost-detection/repost-detection-impl/src/test/java/dev/sheldan/abstracto/repostdetection/service/management/RepostCheckChannelGroupManagementBeanTest.java
View File

@@ -7,10 +7,7 @@ import dev.sheldan.abstracto.repostdetection.repository.RepostCheckChannelReposi
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.*;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Optional;
@@ -105,12 +102,14 @@ public class RepostCheckChannelGroupManagementBeanTest {
@Test
public void testCreateRepostCheckChannelGroup() {
when(aChannelGroup.getId()).thenReturn(CHANNEL_GROUP_ID);
RepostCheckChannelGroup savedGroup = Mockito.mock(RepostCheckChannelGroup.class);
when(repository.save(checkChannelGroupArgumentCaptor.capture())).thenReturn(savedGroup);
RepostCheckChannelGroup createdCheckChannelGroup = testUnit.createRepostCheckChannelGroup(aChannelGroup);
verify(repository, times(1)).save(checkChannelGroupArgumentCaptor.capture());
Assert.assertEquals(checkChannelGroupArgumentCaptor.getValue(), createdCheckChannelGroup);
Assert.assertTrue(createdCheckChannelGroup.getCheckEnabled());
Assert.assertEquals(CHANNEL_GROUP_ID, createdCheckChannelGroup.getId());
Assert.assertEquals(aChannelGroup, createdCheckChannelGroup.getChannelGroup());
Assert.assertEquals(savedGroup, createdCheckChannelGroup);
RepostCheckChannelGroup capturedGroup = checkChannelGroupArgumentCaptor.getValue();
Assert.assertTrue(capturedGroup.getCheckEnabled());
Assert.assertEquals(CHANNEL_GROUP_ID, capturedGroup.getId());
Assert.assertEquals(aChannelGroup, capturedGroup.getChannelGroup());
}
@Test(expected = RepostCheckChannelGroupNotFoundException.class)

3
abstracto-application/abstracto-modules/starboard/starboard-impl/src/test/java/dev/sheldan/abstracto/starboard/listener/StarAddedListenerTest.java
View File

@@ -25,6 +25,7 @@ import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import static org.mockito.Mockito.*;
@@ -149,9 +150,9 @@ public class StarAddedListenerTest {
public void testAddingEmoteReachingThreshold() {
Long requiredStars = 1L;
setupActingAndAuthor();
when(starboardService.createStarboardPost(any(CachedMessage.class), anyList(), eq(userInServerActing), eq(userInAServer))).thenReturn(CompletableFuture.completedFuture(null));
executeAddingTest(requiredStars, null);
verify(metricService, times(2)).incrementCounter(any());
verify(starboardService, times(1)).createStarboardPost(any(CachedMessage.class), anyList(), eq(userInServerActing), eq(userInAServer));
}
@Test

18
abstracto-application/abstracto-modules/starboard/starboard-impl/src/test/java/dev/sheldan/abstracto/starboard/service/StarboardServiceBeanTest.java
View File

@@ -117,6 +117,9 @@ public class StarboardServiceBeanTest {
@Mock
private AUser aUser;
@Mock
private StarboardPostCreatedListenerManager starboardPostCreatedListenerManager;
private static final Long STARRED_USER_ID = 5L;
private static final Long STARRED_SERVER_USER_ID = 2L;
private static final Long SERVER_ID = 6L;
@@ -194,13 +197,10 @@ public class StarboardServiceBeanTest {
CachedMessage message = Mockito.mock(CachedMessage.class);
List<Long> userExceptAuthorIds = Arrays.asList(FIRST_USER_IN_SERVER_ID, SECOND_USER_IN_SERVER_ID);
List<CompletableFuture<Message>> futures = Arrays.asList(CompletableFuture.completedFuture(sendPost));
when(sendPost.getGuild()).thenReturn(guild);
when(sendPost.getChannel()).thenReturn(mockedTextChannel);
when(sendPost.getIdLong()).thenReturn(MESSAGE_ID);
when(userInServerManagementService.loadUserOptional(STARRED_SERVER_USER_ID)).thenReturn(Optional.of(starredUser));
when(userInServerManagementService.loadUserOptional(FIRST_USER_IN_SERVER_ID)).thenReturn(Optional.of(userReacting));
when(userReacting.getUserInServerId()).thenReturn(FIRST_USER_IN_SERVER_ID);
when(userReacting.getUserReference()).thenReturn(aUser);
AChannel channel = Mockito.mock(AChannel.class);
when(channelManagementService.loadChannel(CHANNEL_ID)).thenReturn(channel);
StarboardPost post = Mockito.mock(StarboardPost.class);
@@ -208,13 +208,13 @@ public class StarboardServiceBeanTest {
AUserInAServer secondStarrerUserObj = Mockito.mock(AUserInAServer.class);
when(userInServerManagementService.loadUserOptional(SECOND_USER_IN_SERVER_ID)).thenReturn(Optional.of(secondStarrerUserObj));
when(secondStarrerUserObj.getUserInServerId()).thenReturn(SECOND_USER_IN_SERVER_ID);
when(secondStarrerUserObj.getUserReference()).thenReturn(aUser);
testUnit.persistPost(message, userExceptAuthorIds, futures, CHANNEL_ID, STARRED_SERVER_USER_ID, STARRING_USER_ID);
verify(starboardPostReactorManagementService, times(2)).addReactor(eq(post), userInAServerArgumentCaptor.capture());
List<AUserInAServer> addedReactors = userInAServerArgumentCaptor.getAllValues();
Assert.assertEquals(FIRST_USER_IN_SERVER_ID, addedReactors.get(0).getUserInServerId());
Assert.assertEquals(SECOND_USER_IN_SERVER_ID, addedReactors.get(1).getUserInServerId());
Assert.assertEquals(2, addedReactors.size());
verify(starboardPostCreatedListenerManager, times(1)).sendStarboardPostCreatedEvent(STARRING_USER_ID, post);
}
@Test
@@ -242,7 +242,7 @@ public class StarboardServiceBeanTest {
when(config.getLongValue()).thenReturn(1L);
when(defaultConfigManagementService.getDefaultConfig(StarboardFeatureConfig.STAR_LEVELS_CONFIG_KEY)).thenReturn(config);
when(defaultConfigManagementService.getDefaultConfig(StarboardFeatureConfig.STAR_LVL_CONFIG_PREFIX + 1)).thenReturn(config);
when(starboardPostManagementService.findByStarboardPostMessageId(starboardPostId)).thenReturn(Optional.of(post));
when(starboardPostManagementService.findByStarboardPostId(starboardPostId)).thenReturn(Optional.of(post));
when(userService.retrieveUserForId(STARRED_USER_ID)).thenReturn(CompletableFuture.completedFuture(starredJdaUser));
List<AUserInAServer > userExceptAuthor = new ArrayList<>();
CompletableFuture<Void> future = testUnit.updateStarboardPost(post, message, userExceptAuthor);
@@ -280,17 +280,16 @@ public class StarboardServiceBeanTest {
Integer limit = 3;
AChannel channel = Mockito.mock(AChannel.class);
when(server.getId()).thenReturn(SERVER_ID);
StarboardPostReaction reaction = Mockito.mock(StarboardPostReaction.class);
StarboardPost post1 = Mockito.mock(StarboardPost.class);
when(post1.getReactions()).thenReturn(Arrays.asList(reaction));
when(post1.getPostMessageId()).thenReturn(MESSAGE_ID);
when(post1.getServer()).thenReturn(server);
when(post1.getStarboardChannel()).thenReturn(channel);
StarboardPost post2 = Mockito.mock(StarboardPost.class);
when(post2.getPostMessageId()).thenReturn(SECOND_MESSAGE_ID);
when(post2.getReactions()).thenReturn(new ArrayList<>());
when(post2.getServer()).thenReturn(server);
when(post2.getStarboardChannel()).thenReturn(channel);
when(starboardPostReactorManagementService.getReactorCountOfPost(post1)).thenReturn(1L);
when(starboardPostReactorManagementService.getReactorCountOfPost(post2)).thenReturn(0L);
List<StarboardPost> topPosts = Arrays.asList(post1, post2);
when(starboardPostManagementService.retrieveTopPosts(SERVER_ID, limit)).thenReturn(topPosts);
CompletableFuture<StarStatsUser> statsUser = CompletableFuture.completedFuture(Mockito.mock(StarStatsUser.class));
@@ -339,10 +338,9 @@ public class StarboardServiceBeanTest {
AServer server = Mockito.mock(AServer.class);
when(server.getId()).thenReturn(SERVER_ID);
when(post.getServer()).thenReturn(server);
StarboardPostReaction reaction = Mockito.mock(StarboardPostReaction.class);
when(post.getReactions()).thenReturn(Collections.singletonList(reaction));
when(starboardChannel.getId()).thenReturn(STARBOARD_CHANNEL_ID);
when(post.getPostMessageId()).thenReturn(MESSAGE_ID);
when(starboardPostReactorManagementService.getReactorCountOfPost(post)).thenReturn(1L);
when(starboardPostManagementService.retrieveTopPostsForUserInServer(SERVER_ID, STARRED_USER_ID, 3)).thenReturn(Collections.singletonList(post));
MemberStarStatsModel returnedModel = testUnit.retrieveStarStatsForMember(starredMember);
Assert.assertEquals(receivedStars, returnedModel.getReceivedStars());

45
abstracto-application/abstracto-modules/starboard/starboard-impl/src/test/java/dev/sheldan/abstracto/starboard/service/management/StarboardPostManagementServiceBeanTest.java
View File

@@ -13,6 +13,7 @@ import dev.sheldan.abstracto.starboard.repository.StarboardPostRepository;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
@@ -67,14 +68,18 @@ public class StarboardPostManagementServiceBeanTest {
when(channelManagementService.loadChannel(SOURCE_CHANNEL_ID)).thenReturn(sourceChannel);
AUser aUser = Mockito.mock(AUser.class);
when(aUserInAServer.getUserReference()).thenReturn(aUser);
ArgumentCaptor<StarboardPost> argumentCaptor = ArgumentCaptor.forClass(StarboardPost.class);
StarboardPost savedPost = Mockito.mock(StarboardPost.class);
when(repository.save(argumentCaptor.capture())).thenReturn(savedPost);
StarboardPost createdStarboardPost = testUnit.createStarboardPost(starredMessage, aUserInAServer, postInStarboard);
verify(repository, times(1)).save(createdStarboardPost);
Assert.assertEquals(starboardChannel, createdStarboardPost.getStarboardChannel());
Assert.assertEquals(starboardPostId, createdStarboardPost.getStarboardMessageId());
Assert.assertEquals(starredMessageId, createdStarboardPost.getPostMessageId());
Assert.assertEquals(aUserInAServer, createdStarboardPost.getAuthor());
Assert.assertEquals(sourceChannel, createdStarboardPost.getSourceChannel());
Assert.assertFalse(createdStarboardPost.isIgnored());
Assert.assertEquals(savedPost, createdStarboardPost);
StarboardPost capturedPost = argumentCaptor.getValue();
Assert.assertEquals(starboardChannel, capturedPost.getStarboardChannel());
Assert.assertEquals(starboardPostId, capturedPost.getStarboardMessageId());
Assert.assertEquals(starredMessageId, capturedPost.getPostMessageId());
Assert.assertEquals(aUserInAServer, capturedPost.getAuthor());
Assert.assertEquals(sourceChannel, capturedPost.getSourceChannel());
Assert.assertFalse(capturedPost.isIgnored());
}
@Test
@@ -83,20 +88,21 @@ public class StarboardPostManagementServiceBeanTest {
Long messageId = 6L;
testUnit.setStarboardPostMessageId(post, messageId);
verify(post, times(1)).setStarboardMessageId(messageId);
verify(repository, times(1)).save(post);
}
@Test
public void testRetrieveTopPosts() {
Integer count = 2;
Long postId = 1L;
Long postId2 = 3L;
StarboardPost starboardPost1 = Mockito.mock(StarboardPost.class);
when(starboardPost1.getReactions()).thenReturn(Arrays.asList(Mockito.mock(StarboardPostReaction.class), Mockito.mock(StarboardPostReaction.class)));
StarboardPost starboardPost2 = Mockito.mock(StarboardPost.class);
when(starboardPost2.getReactions()).thenReturn(Arrays.asList(Mockito.mock(StarboardPostReaction.class)));
StarboardPost starboardPost3 = Mockito.mock(StarboardPost.class);
when(starboardPost3.getReactions()).thenReturn(new ArrayList<>());
List<StarboardPost> posts = Arrays.asList(starboardPost1, starboardPost2, starboardPost3);
when(repository.findByServer_Id(SERVER_ID)).thenReturn(posts);
List<StarboardPost> posts = Arrays.asList(starboardPost1, starboardPost2);
List<Long> postIds = Arrays.asList(postId, postId2);
when(repository.getTopStarboardPostsForServer(SERVER_ID, count)).thenReturn(postIds);
when(repository.findAllById(postIds)).thenReturn(posts);
List<StarboardPost> topPosts = testUnit.retrieveTopPosts(SERVER_ID, count);
Assert.assertEquals(count.intValue(), topPosts.size());
StarboardPost topMostPost = topPosts.get(0);
@@ -109,6 +115,9 @@ public class StarboardPostManagementServiceBeanTest {
@Test
public void testRetrieveMoreThanAvailable() {
Integer count = 5;
Long postId = 1L;
Long postId2 = 2L;
Long postId3 = 3L;
StarboardPost starboardPost1 = Mockito.mock(StarboardPost.class);
when(starboardPost1.getReactions()).thenReturn(Arrays.asList(Mockito.mock(StarboardPostReaction.class), Mockito.mock(StarboardPostReaction.class)));
StarboardPost starboardPost2 = Mockito.mock(StarboardPost.class);
@@ -116,7 +125,9 @@ public class StarboardPostManagementServiceBeanTest {
StarboardPost starboardPost3 = Mockito.mock(StarboardPost.class);
when(starboardPost3.getReactions()).thenReturn(new ArrayList<>());
List<StarboardPost> posts = Arrays.asList(starboardPost1, starboardPost2, starboardPost3);
when(repository.findByServer_Id(SERVER_ID)).thenReturn(posts);
List<Long> postIds = Arrays.asList(postId, postId2, postId3);
when(repository.getTopStarboardPostsForServer(SERVER_ID, 5)).thenReturn(postIds);
when(repository.findAllById(postIds)).thenReturn(posts);
List<StarboardPost> topPosts = testUnit.retrieveTopPosts(SERVER_ID, count);
StarboardPost topMostPost = topPosts.get(0);
StarboardPost secondTop = topPosts.get(1);
@@ -194,11 +205,9 @@ public class StarboardPostManagementServiceBeanTest {
@Test
public void testRetrievePostCount() {
StarboardPost starboardPost1 = Mockito.mock(StarboardPost.class);
StarboardPost starboardPost2 = Mockito.mock(StarboardPost.class);
List<StarboardPost> posts = Arrays.asList(starboardPost1, starboardPost2);
when(repository.findByServer_Id(SERVER_ID)).thenReturn(posts);
Long expectedCount = 2L;
when(repository.countByServer_Id(SERVER_ID)).thenReturn(expectedCount);
Long retrievedPostCount = testUnit.getPostCount(SERVER_ID);
Assert.assertEquals(posts.size(), retrievedPostCount.intValue());
Assert.assertEquals(expectedCount, retrievedPostCount);
}
}

7
abstracto-application/abstracto-modules/statistic/statistic-impl/src/test/java/dev/sheldan/abstracto/statistic/emote/listener/DeleteTrackedEmoteListenerTest.java
View File

@@ -26,17 +26,12 @@ public class DeleteTrackedEmoteListenerTest {
@Mock
private EmoteDeletedModel model;
private static final Long SERVER_ID = 4L;
private static final Long EMOTE_ID = 4L;
@Test
public void testEmoteDeleted() {
Emote emote = Mockito.mock(Emote.class);
when(emote.getIdLong()).thenReturn(EMOTE_ID);
when(model.getEmote()).thenReturn(emote);
when(model.getServerId()).thenReturn(SERVER_ID);
testUnit.execute(model);
verify(trackedEmoteManagementService, times(1)).markAsDeleted(SERVER_ID, EMOTE_ID);
verify(trackedEmoteManagementService, times(1)).markAsDeleted(emote);
}
@Test

18
abstracto-application/abstracto-modules/statistic/statistic-impl/src/test/java/dev/sheldan/abstracto/statistic/emote/listener/EmoteTrackingListenerTest.java
View File

@@ -8,6 +8,8 @@ import dev.sheldan.abstracto.statistic.emote.service.TrackedEmoteService;
import net.dv8tion.jda.api.entities.Emote;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Message;
import org.apache.commons.collections4.Bag;
import org.apache.commons.collections4.bag.HashBag;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -52,19 +54,19 @@ public class EmoteTrackingListenerTest {
@Test
public void testExecuteOneEmote() {
List<Emote> emotesBag = new ArrayList<>();
Bag<Emote> emotesBag = new HashBag<>();
emotesBag.add(emote1);
when(guildService.getGuildById(SERVER_ID)).thenReturn(guild);
when(messageReceivedModel.getMessage()).thenReturn(message);
when(messageReceivedModel.getServerId()).thenReturn(SERVER_ID);
when(message.getEmotes()).thenReturn(emotesBag);
when(message.getEmotesBag()).thenReturn(emotesBag);
testUnit.execute(messageReceivedModel);
verify(trackedEmoteService, times(1)).addEmoteToRuntimeStorage(emote1, guild, 1L);
}
@Test
public void testExecuteOneEmoteMultipleTimes() {
List<Emote> emotesBag = new ArrayList<>();
Bag<Emote> emotesBag = new HashBag<>();
when(emote1.getIdLong()).thenReturn(EMOTE_ID);
when(emote2.getIdLong()).thenReturn(EMOTE_ID);
emotesBag.add(emote1);
@@ -72,14 +74,14 @@ public class EmoteTrackingListenerTest {
when(guildService.getGuildById(SERVER_ID)).thenReturn(guild);
when(messageReceivedModel.getServerId()).thenReturn(SERVER_ID);
when(messageReceivedModel.getMessage()).thenReturn(message);
when(message.getEmotes()).thenReturn(emotesBag);
when(message.getEmotesBag()).thenReturn(emotesBag);
testUnit.execute(messageReceivedModel);
verify(trackedEmoteService, times(1)).addEmoteToRuntimeStorage(any(CachedEmote.class), eq(guild), eq(2L));
verify(trackedEmoteService, times(1)).addEmoteToRuntimeStorage(any(Emote.class), eq(guild), eq(2L));
}
@Test
public void testExecuteMultipleEmotes() {
List<Emote> emotesBag = new ArrayList<>();
Bag<Emote> emotesBag = new HashBag<>();
when(emote1.getIdLong()).thenReturn(EMOTE_ID);
when(emote2.getIdLong()).thenReturn(EMOTE_ID + 1);
emotesBag.add(emote1);
@@ -87,7 +89,7 @@ public class EmoteTrackingListenerTest {
when(guildService.getGuildById(SERVER_ID)).thenReturn(guild);
when(messageReceivedModel.getServerId()).thenReturn(SERVER_ID);
when(messageReceivedModel.getMessage()).thenReturn(message);
when(message.getEmotes()).thenReturn(emotesBag);
when(message.getEmotesBag()).thenReturn(emotesBag);
testUnit.execute(messageReceivedModel);
verify(trackedEmoteService, times(1)).addEmoteToRuntimeStorage(emote1, guild, 1L);
verify(trackedEmoteService, times(1)).addEmoteToRuntimeStorage(emote2, guild, 1L);
@@ -95,7 +97,7 @@ public class EmoteTrackingListenerTest {
@Test
public void testExecuteNoEmote() {
when(message.getEmotes()).thenReturn(new ArrayList<>());
when(message.getEmotesBag()).thenReturn(new HashBag<>());
when(messageReceivedModel.getMessage()).thenReturn(message);
testUnit.execute(messageReceivedModel);
verify(trackedEmoteService, times(0)).addEmoteToRuntimeStorage(any(Emote.class), any(), anyLong());

5
abstracto-application/abstracto-modules/statistic/statistic-impl/src/test/java/dev/sheldan/abstracto/statistic/emote/listener/UpdateTrackedEmoteListenerTest.java
View File

@@ -29,12 +29,9 @@ public class UpdateTrackedEmoteListenerTest {
@Test
public void testEmoteUpdated() {
Long serverId = 1L;
Long emoteId = 2L;
Emote changedEmote = Mockito.mock(Emote.class);
when(changedEmote.getIdLong()).thenReturn(emoteId);
TrackedEmote trackedEmote = Mockito.mock(TrackedEmote.class);
when(trackedEmoteManagementService.loadByEmoteId(emoteId, serverId)).thenReturn(trackedEmote);
when(trackedEmoteManagementService.loadByEmote(changedEmote)).thenReturn(trackedEmote);
String newValue = "AFTER";
when(model.getEmote()).thenReturn(changedEmote);
when(model.getNewValue()).thenReturn(newValue);

25
abstracto-application/abstracto-modules/suggestion/suggestion-impl/src/test/java/dev/sheldan/abstracto/suggestion/service/management/SuggestionManagementServiceBeanTest.java
View File

@@ -17,6 +17,7 @@ import net.dv8tion.jda.api.entities.MessageChannel;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
@@ -70,11 +71,15 @@ public class SuggestionManagementServiceBeanTest {
when(message.getGuild()).thenReturn(guild);
when(guild.getId()).thenReturn("8");
long suggestionId = 1L;
ArgumentCaptor<Suggestion> suggestionArgumentCaptor = ArgumentCaptor.forClass(Suggestion.class);
Suggestion savedSuggestion = Mockito.mock(Suggestion.class);
when(suggestionRepository.save(suggestionArgumentCaptor.capture())).thenReturn(savedSuggestion);
Suggestion createdSuggestion = testUnit.createSuggestion(aUserInAServer, text, message, suggestionId);
verify(suggestionRepository, times(1)).save(createdSuggestion);
Assert.assertEquals(SuggestionState.NEW, createdSuggestion.getState());
Assert.assertEquals(aUserInAServer, createdSuggestion.getSuggester());
Assert.assertEquals(server, createdSuggestion.getServer());
Assert.assertEquals(savedSuggestion, createdSuggestion);
Suggestion capturedSuggestion = suggestionArgumentCaptor.getValue();
Assert.assertEquals(SuggestionState.NEW, capturedSuggestion.getState());
Assert.assertEquals(aUserInAServer, capturedSuggestion.getSuggester());
Assert.assertEquals(server, capturedSuggestion.getServer());
}
@Test
@@ -92,11 +97,15 @@ public class SuggestionManagementServiceBeanTest {
when(guild.getId()).thenReturn("5");
when(userInServerManagementService.loadOrCreateUser(member)).thenReturn(aUserInAServer);
long suggestionId = 1L;
ArgumentCaptor<Suggestion> suggestionArgumentCaptor = ArgumentCaptor.forClass(Suggestion.class);
Suggestion savedSuggestion = Mockito.mock(Suggestion.class);
when(suggestionRepository.save(suggestionArgumentCaptor.capture())).thenReturn(savedSuggestion);
Suggestion createdSuggestion = testUnit.createSuggestion(member, text, message, suggestionId);
verify(suggestionRepository, times(1)).save(createdSuggestion);
Assert.assertEquals(SuggestionState.NEW, createdSuggestion.getState());
Assert.assertEquals(aUserInAServer, createdSuggestion.getSuggester());
Assert.assertEquals(server, createdSuggestion.getServer());
Assert.assertEquals(savedSuggestion, createdSuggestion);
Suggestion capturedSuggestion = suggestionArgumentCaptor.getValue();
Assert.assertEquals(SuggestionState.NEW, capturedSuggestion.getState());
Assert.assertEquals(aUserInAServer, capturedSuggestion.getSuggester());
Assert.assertEquals(server, capturedSuggestion.getServer());
}
@Test

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/CommandReceivedHandler.java
View File

@@ -113,7 +113,7 @@ public class CommandReceivedHandler extends ListenerAdapter {
List<String> parameters = Arrays.asList(contentStripped.split(" "));
UnParsedCommandParameter unParsedParameter = new UnParsedCommandParameter(contentStripped, event.getMessage());
String commandName = commandManager.getCommandName(parameters.get(0), event.getGuild().getIdLong());
foundCommand = commandManager.findCommandByParameters(commandName, unParsedParameter);
foundCommand = commandManager.findCommandByParameters(commandName, unParsedParameter, event.getGuild().getIdLong());
tryToExecuteFoundCommand(event, foundCommand, unParsedParameter);
} catch (Exception e) {

4
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/config/CommandConfigListenerAsync.java
View File

@@ -1,7 +1,7 @@
package dev.sheldan.abstracto.core.command.config;
import dev.sheldan.abstracto.core.command.Command;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.service.management.CommandInServerManagementService;
import dev.sheldan.abstracto.core.command.service.management.CommandManagementService;
import dev.sheldan.abstracto.core.listener.DefaultListenerResult;
@@ -39,7 +39,7 @@ public class CommandConfigListenerAsync implements AsyncServerCreatedListener {
if(command.getConfiguration() != null) {
ACommand aCommand = commandManagementService.findCommandByName(command.getConfiguration().getName());
if(!commandInServerManagementService.doesCommandExistInServer(aCommand, server)) {
commandInServerManagementService.crateCommandInServer(aCommand, server);
commandInServerManagementService.createCommandInServer(aCommand, server);
}
}
});

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/post/ConditionPostExecution.java
View File

@@ -5,7 +5,7 @@ import dev.sheldan.abstracto.core.command.config.features.CoreFeatureConfig;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.execution.ResultState;
import dev.sheldan.abstracto.core.command.models.condition.GenericConditionModel;
import dev.sheldan.abstracto.core.command.model.condition.GenericConditionModel;
import dev.sheldan.abstracto.core.command.service.PostCommandExecution;
import dev.sheldan.abstracto.core.models.GuildChannelMember;
import dev.sheldan.abstracto.core.service.ChannelService;

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/repository/ChannelGroupCommandRepository.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.core.command.repository;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.models.database.AChannelGroup;
import dev.sheldan.abstracto.core.models.database.AChannelGroupCommand;
import org.springframework.data.jpa.repository.JpaRepository;

18
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/repository/CommandInServerAliasRepository.java Normal file
View File

@@ -0,0 +1,18 @@
package dev.sheldan.abstracto.core.command.repository;
import dev.sheldan.abstracto.core.command.model.database.ACommandInServerAlias;
import dev.sheldan.abstracto.core.command.model.database.CommandInServerAliasId;
import dev.sheldan.abstracto.core.models.database.AServer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Optional;
@Repository
public interface CommandInServerAliasRepository extends JpaRepository<ACommandInServerAlias, CommandInServerAliasId> {
List<ACommandInServerAlias> findByCommandInAServer_ServerReference(AServer server);
Optional<ACommandInServerAlias> findByCommandInAServer_ServerReferenceAndAliasId_NameEqualsIgnoreCase(AServer server, String name);
List<ACommandInServerAlias> findByCommandInAServer_ServerReferenceAndCommandInAServer_CommandReference_NameEqualsIgnoreCase(AServer server, String name);
boolean existsByCommandInAServer_ServerReferenceAndAliasId_NameEqualsIgnoreCase(AServer server, String name);
}

8
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/repository/CommandInServerRepository.java
View File

@@ -1,16 +1,18 @@
package dev.sheldan.abstracto.core.command.repository;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.models.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommandInAServer;
import dev.sheldan.abstracto.core.models.database.AServer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.Optional;
@Repository
public interface CommandInServerRepository extends JpaRepository<ACommandInAServer, Long> {
ACommandInAServer findByServerReferenceAndCommandReference(AServer server, ACommand command);
Optional<ACommandInAServer> findByServerReferenceAndCommandReference(AServer server, ACommand command);
ACommandInAServer findByServerReference_IdAndCommandReference(Long serverId, ACommand command);
}

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/repository/CommandRepository.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.core.command.repository;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/repository/ModuleRepository.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.core.command.repository;
import dev.sheldan.abstracto.core.command.models.database.AModule;
import dev.sheldan.abstracto.core.command.model.database.AModule;
import org.springframework.data.jpa.repository.JpaRepository;

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/ChannelGroupCommandServiceBean.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.core.command.service;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.service.management.ChannelGroupCommandManagementService;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AChannelGroupCommand;

73
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/CommandInServerAliasServiceBean.java Normal file
View File

@@ -0,0 +1,73 @@
package dev.sheldan.abstracto.core.command.service;
import dev.sheldan.abstracto.core.command.Command;
import dev.sheldan.abstracto.core.command.exception.CommandAliasAlreadyExistsException;
import dev.sheldan.abstracto.core.command.exception.CommandAliasDoesNotExistsException;
import dev.sheldan.abstracto.core.command.exception.CommandAliasHidesCommandException;
import dev.sheldan.abstracto.core.command.model.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.model.database.ACommandInServerAlias;
import dev.sheldan.abstracto.core.command.service.management.CommandInServerAliasManagementServiceBean;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
@Component
public class CommandInServerAliasServiceBean implements CommandInServerAliasService {
@Autowired
private CommandInServerAliasManagementServiceBean commandInServerAliasManagementServiceBean;
@Autowired
private ServerManagementService serverManagementService;
@Autowired
private CommandInServerService commandInServerService;
@Autowired
private CommandRegistry commandRegistry;
@Override
public ACommandInServerAlias createAliasForCommandInServer(Long serverId, String commandName, String alias) {
AServer server = serverManagementService.loadServer(serverId);
Optional<ACommandInServerAlias> existingAlias = commandInServerAliasManagementServiceBean.getCommandInServerAlias(server, alias);
if(existingAlias.isPresent()) {
throw new CommandAliasAlreadyExistsException(existingAlias.get().getCommandInAServer().getCommandReference().getName());
}
Optional<Command> existingCommand = commandRegistry.getCommandByNameOptional(alias, false, serverId);
if(existingCommand.isPresent()) {
throw new CommandAliasHidesCommandException(existingCommand.get().getConfiguration().getName());
}
ACommandInAServer aCommandInAServer = commandInServerService.getCommandInAServer(server, commandName);
return commandInServerAliasManagementServiceBean.createAliasForCommand(aCommandInAServer, alias);
}
@Override
public Optional<ACommandInServerAlias> getCommandInServerAlias(Long serverId, String text) {
AServer server = serverManagementService.loadServer(serverId);
return commandInServerAliasManagementServiceBean.getCommandInServerAlias(server, text);
}
@Override
public void deleteCommandInServerAlias(Long serverId, String name) {
AServer server = serverManagementService.loadServer(serverId);
Optional<ACommandInServerAlias> existingAlias = commandInServerAliasManagementServiceBean.getCommandInServerAlias(server, name);
if(existingAlias.isPresent()) {
commandInServerAliasManagementServiceBean.deleteCommandInServerAlias(existingAlias.get());
} else {
throw new CommandAliasDoesNotExistsException();
}
}
@Override
public List<String> getAliasesForCommand(Long serverId, String commandName) {
AServer server = serverManagementService.loadServer(serverId);
return commandInServerAliasManagementServiceBean.getAliasesForCommandInServer(server, commandName)
.stream().map(alias -> alias.getAliasId().getName())
.collect(Collectors.toList());
}
}

35
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/CommandInServerServiceBean.java Normal file
View File

@@ -0,0 +1,35 @@
package dev.sheldan.abstracto.core.command.service;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.service.management.CommandInServerManagementService;
import dev.sheldan.abstracto.core.command.service.management.CommandManagementService;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class CommandInServerServiceBean implements CommandInServerService {
@Autowired
private CommandManagementService commandManagementService;
@Autowired
private ServerManagementService serverManagementService;
@Autowired
private CommandInServerManagementService commandInServerManagementService;
@Override
public ACommandInAServer getCommandInAServer(Long serverId, String name) {
AServer server = serverManagementService.loadServer(serverId);
return getCommandInAServer(server, name);
}
@Override
public ACommandInAServer getCommandInAServer(AServer server, String name) {
ACommand command = commandManagementService.findCommandByName(name);
return commandInServerManagementService.getCommandForServer(command, server);
}
}

150
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/CommandManager.java
View File

@@ -7,9 +7,12 @@ import dev.sheldan.abstracto.core.command.config.ModuleDefinition;
import dev.sheldan.abstracto.core.command.exception.CommandNotFoundException;
import dev.sheldan.abstracto.core.command.exception.InsufficientParametersException;
import dev.sheldan.abstracto.core.command.execution.UnParsedCommandParameter;
import dev.sheldan.abstracto.core.command.model.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.model.database.ACommandInServerAlias;
import dev.sheldan.abstracto.core.metric.service.MetricService;
import dev.sheldan.abstracto.core.service.ConfigService;
import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import net.dv8tion.jda.api.entities.Message;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@@ -17,6 +20,7 @@ import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.function.Predicate;
@Service
public class CommandManager implements CommandRegistry {
@@ -34,52 +38,90 @@ public class CommandManager implements CommandRegistry {
@Autowired
private MetricService metricService;
@Autowired
private CommandInServerAliasService commandInServerAliasService;
@Autowired
private ServerManagementService serverManagementService;
@Override
public Command findCommandByParameters(String name, UnParsedCommandParameter unParsedCommandParameter) {
Optional<Command> commandOptional = commands.stream().filter((Command o )-> {
CommandConfiguration commandConfiguration = o.getConfiguration();
if(commandConfiguration == null) {
return false;
}
if(!commandNameMatches(name, commandConfiguration)) {
return false;
}
boolean parameterFit;
if(commandConfiguration.getParameters() != null){
if(commandConfiguration.getNecessaryParameterCount() > unParsedCommandParameter.getParameters().size()) {
String nextParameterName = commandConfiguration.getParameters().get(commandConfiguration.getNecessaryParameterCount() - 1).getName();
metricService.incrementCounter(CommandReceivedHandler.COMMANDS_WRONG_PARAMETER_COUNTER);
throw new InsufficientParametersException(o, nextParameterName);
}
parameterFit = true;
} else {
parameterFit = unParsedCommandParameter.getParameters().isEmpty();
}
return parameterFit;
}).findFirst();
public Command findCommandByParameters(String name, UnParsedCommandParameter unParsedCommandParameter, Long serverId) {
Optional<Command> commandOptional = commands.stream().filter(getCommandByNameAndParameterPredicate(name, unParsedCommandParameter)).findFirst();
if(!commandOptional.isPresent()) {
commandOptional = getCommandViaAliasAndParameter(name, unParsedCommandParameter, serverId);
}
if(commandOptional.isPresent()){
return commandOptional.get();
}
throw new CommandNotFoundException();
}
private boolean commandNameMatches(String name, CommandConfiguration commandConfiguration) {
boolean commandNameMatches = commandConfiguration.getName().equalsIgnoreCase(name);
if(commandNameMatches) {
return true;
private Optional<Command> getCommandViaAliasAndParameter(String name, UnParsedCommandParameter unParsedCommandParameter, Long serverId) {
Optional<ACommandInServerAlias> aliasOptional = commandInServerAliasService.getCommandInServerAlias(serverId, name);
if(aliasOptional.isPresent()) {
// if its present, retrieve the original command
ACommandInAServer command = aliasOptional.get().getCommandInAServer();
// and find the command based on the newly found name
return commands.stream().filter(getCommandByNameAndParameterPredicate(command.getCommandReference().getName(), unParsedCommandParameter)).findFirst();
}
boolean aliasesMatch = false;
if(commandConfiguration.getAliases() != null) {
aliasesMatch = commandConfiguration.getAliases().stream().anyMatch(s -> s.equalsIgnoreCase(name));
}
return aliasesMatch;
return Optional.empty();
}
public Command findCommand(String name) {
private Optional<Command> getCommandViaAlias(String name, Long serverId) {
Optional<ACommandInServerAlias> aliasOptional = commandInServerAliasService.getCommandInServerAlias(serverId, name);
if(aliasOptional.isPresent()) {
// if its present, retrieve the original command
ACommandInAServer command = aliasOptional.get().getCommandInAServer();
// and find the command based on the newly found name
return commands.stream().filter(getCommandByNamePredicate(command.getCommandReference().getName())).findFirst();
}
return Optional.empty();
}
private Predicate<Command> getCommandByNameAndParameterPredicate(String name, UnParsedCommandParameter unParsedCommandParameter) {
return (Command commandObj) -> {
CommandConfiguration commandConfiguration = commandObj.getConfiguration();
if (commandConfiguration == null) {
return false;
}
if (!commandNameOrAliasMatches(name, commandConfiguration)) {
return false;
}
return verifyCommandConfiguration(unParsedCommandParameter, commandObj, commandConfiguration);
};
}
private Predicate<Command> getCommandByNamePredicate(String name) {
return (Command commandObj) -> {
CommandConfiguration commandConfiguration = commandObj.getConfiguration();
if (commandConfiguration == null) {
return false;
}
return commandNameOrAliasMatches(name, commandConfiguration);
};
}
private boolean verifyCommandConfiguration(UnParsedCommandParameter unParsedCommandParameter, Command command, CommandConfiguration commandConfiguration) {
if(commandConfiguration.getParameters() != null && commandConfiguration.getNecessaryParameterCount() > unParsedCommandParameter.getParameters().size()){
String nextParameterName = commandConfiguration.getParameters().get(commandConfiguration.getNecessaryParameterCount() - 1).getName();
metricService.incrementCounter(CommandReceivedHandler.COMMANDS_WRONG_PARAMETER_COUNTER);
throw new InsufficientParametersException(command, nextParameterName);
}
return true;
}
private boolean commandNameOrAliasMatches(String name, CommandConfiguration commandConfiguration) {
return commandConfiguration.getName().equalsIgnoreCase(name) ||
commandConfiguration.getAliases() != null && commandConfiguration.getAliases().stream().anyMatch(s -> s.equalsIgnoreCase(name));
}
@Override
public Command findCommandViaName(String name) {
return commands.stream().filter((Command o )-> {
CommandConfiguration commandConfiguration = o.getConfiguration();
return commandConfiguration.getName().equals(name);
}).findFirst().orElseThrow(CommandNotFoundException::new);
return commandConfiguration.getName().equalsIgnoreCase(name);
}).findFirst()
.orElseThrow(CommandNotFoundException::new);
}
@Override
@@ -101,22 +143,50 @@ public class CommandManager implements CommandRegistry {
@Override
public boolean isCommand(Message message) {
return message.getContentRaw().startsWith(configService.getStringValue(PREFIX, message.getGuild().getIdLong(), getDefaultPrefix()));
return message.getContentRaw().startsWith(getPrefix(message.getGuild().getIdLong()));
}
@Override
public boolean commandExists(String name) {
return commands.stream().anyMatch(command -> command.getConfiguration().getName().equalsIgnoreCase(name));
public boolean commandExists(String name, boolean searchAliases, Long serverId) {
boolean defaultCommands = commands.stream().anyMatch(findCommandViaCommandConfig(name));
if(defaultCommands) {
return true;
}
if(searchAliases) {
return commandInServerAliasService.getCommandInServerAlias(serverId, name).isPresent();
}
return false;
}
private Predicate<Command> findCommandViaCommandConfig(String name) {
return command -> command.getConfiguration().getName().equalsIgnoreCase(name) || command.getConfiguration().getAliases().stream().anyMatch(s -> s.equalsIgnoreCase(name));
}
@Override
public Command getCommandByName(String name) {
return commands.stream().filter(command -> command.getConfiguration().getName().equalsIgnoreCase(name)).findFirst().orElse(null);
public Command getCommandByName(String name, boolean searchAliases, Long serverId) {
Optional<Command> defaultCommand = commands.stream().filter(findCommandViaCommandConfig(name)).findFirst();
if(defaultCommand.isPresent()) {
return defaultCommand.get();
} else {
if(searchAliases) {
return getCommandViaAlias(name, serverId).orElse(null);
}
return null;
}
}
@Override
public Optional<Command> getCommandByNameOptional(String name, boolean searchAliases, Long serverId) {
return Optional.ofNullable(getCommandByName(name, searchAliases, serverId));
}
@Override
public String getCommandName(String input, Long serverId) {
return input.replaceFirst(configService.getStringValue(PREFIX, serverId, getDefaultPrefix()), "");
return input.replaceFirst(getPrefix(serverId), "");
}
private String getPrefix(Long serverId) {
return configService.getStringValue(PREFIX, serverId, getDefaultPrefix());
}
private String getDefaultPrefix() {

8
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/CommandServiceBean.java
View File

@@ -10,9 +10,9 @@ import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
import dev.sheldan.abstracto.core.command.config.Parameters;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.UnParsedCommandParameter;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.models.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.models.database.AModule;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.model.database.AModule;
import dev.sheldan.abstracto.core.command.service.management.CommandInServerManagementService;
import dev.sheldan.abstracto.core.command.service.management.CommandManagementService;
import dev.sheldan.abstracto.core.command.service.management.FeatureManagementService;
@@ -175,7 +175,7 @@ public class CommandServiceBean implements CommandService {
public CompletableFuture<Parameters> getParametersForCommand(String commandName, Message messageContainingContent) {
String contentStripped = messageContainingContent.getContentRaw();
UnParsedCommandParameter unParsedParameter = getUnParsedCommandParameter(contentStripped, messageContainingContent);
Command command = commandRegistry.findCommandByParameters(commandName, unParsedParameter);
Command command = commandRegistry.findCommandByParameters(commandName, unParsedParameter, messageContainingContent.getGuild().getIdLong());
return commandReceivedHandler.getParsedParameters(unParsedParameter, command, messageContainingContent);
}

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/ExceptionServiceBean.java
View File

@@ -3,7 +3,7 @@ package dev.sheldan.abstracto.core.command.service;
import dev.sheldan.abstracto.core.command.Command;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.models.exception.GenericExceptionModel;
import dev.sheldan.abstracto.core.command.model.exception.GenericExceptionModel;
import dev.sheldan.abstracto.core.models.FullUser;
import dev.sheldan.abstracto.core.models.FullUserInServer;
import dev.sheldan.abstracto.core.models.database.AUser;

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/ChannelGroupCommandManagementServiceBean.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.core.command.service.management;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.repository.ChannelGroupCommandRepository;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
import dev.sheldan.abstracto.core.models.database.AChannelGroup;

59
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerAliasManagementServiceBean.java Normal file
View File

@@ -0,0 +1,59 @@
package dev.sheldan.abstracto.core.command.service.management;
import dev.sheldan.abstracto.core.command.model.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.model.database.ACommandInServerAlias;
import dev.sheldan.abstracto.core.command.model.database.CommandInServerAliasId;
import dev.sheldan.abstracto.core.command.repository.CommandInServerAliasRepository;
import dev.sheldan.abstracto.core.models.database.AServer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Optional;
@Component
public class CommandInServerAliasManagementServiceBean implements CommandInServerAliasManagementService {
@Autowired
private CommandInServerAliasRepository repository;
@Override
public List<ACommandInServerAlias> getAliasesInServer(AServer server) {
return repository.findByCommandInAServer_ServerReference(server);
}
@Override
public boolean doesCommandInServerAliasExist(AServer server, String alias) {
return repository.existsByCommandInAServer_ServerReferenceAndAliasId_NameEqualsIgnoreCase(server, alias);
}
@Override
public Optional<ACommandInServerAlias> getCommandInServerAlias(AServer server, String alias) {
return repository.findByCommandInAServer_ServerReferenceAndAliasId_NameEqualsIgnoreCase(server, alias);
}
@Override
public ACommandInServerAlias createAliasForCommand(ACommandInAServer commandInAServer, String aliasName) {
CommandInServerAliasId identifier = CommandInServerAliasId
.builder()
.commandInServerId(commandInAServer.getCommandInServerId())
.name(aliasName)
.build();
ACommandInServerAlias alias = ACommandInServerAlias
.builder()
.commandInAServer(commandInAServer)
.aliasId(identifier)
.build();
return repository.save(alias);
}
@Override
public void deleteCommandInServerAlias(ACommandInServerAlias alias) {
repository.delete(alias);
}
@Override
public List<ACommandInServerAlias> getAliasesForCommandInServer(AServer server, String commandName) {
return repository.findByCommandInAServer_ServerReferenceAndCommandInAServer_CommandReference_NameEqualsIgnoreCase(server, commandName);
}
}

11
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerManagementServiceBean.java
View File

@@ -1,7 +1,8 @@
package dev.sheldan.abstracto.core.command.service.management;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.models.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.exception.CommandNotFoundException;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.repository.CommandInServerRepository;
import dev.sheldan.abstracto.core.models.database.AServer;
import lombok.extern.slf4j.Slf4j;
@@ -17,7 +18,7 @@ public class CommandInServerManagementServiceBean implements CommandInServerMana
@Override
public ACommandInAServer crateCommandInServer(ACommand command, AServer server) {
public ACommandInAServer createCommandInServer(ACommand command, AServer server) {
ACommandInAServer commandInAServer = ACommandInAServer
.builder()
.commandReference(command)
@@ -30,12 +31,12 @@ public class CommandInServerManagementServiceBean implements CommandInServerMana
@Override
public boolean doesCommandExistInServer(ACommand command, AServer server) {
return getCommandForServer(command, server) != null;
return repository.findByServerReferenceAndCommandReference(server, command).isPresent();
}
@Override
public ACommandInAServer getCommandForServer(ACommand command, AServer server) {
return repository.findByServerReferenceAndCommandReference(server, command);
return repository.findByServerReferenceAndCommandReference(server, command).orElseThrow(CommandNotFoundException::new);
}
@Override

10
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/CommandManagementServiceBean.java
View File

@@ -1,14 +1,15 @@
package dev.sheldan.abstracto.core.command.service.management;
import dev.sheldan.abstracto.core.command.exception.CommandNotFoundException;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.models.database.AModule;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.AModule;
import dev.sheldan.abstracto.core.command.repository.CommandRepository;
import dev.sheldan.abstracto.core.models.database.AFeature;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Optional;
@Component
@@ -58,4 +59,9 @@ public class CommandManagementServiceBean implements CommandManagementService {
return commandRepository.existsByNameIgnoreCase(name.toLowerCase());
}
@Override
public List<ACommand> getAllCommands() {
return commandRepository.findAll();
}
}

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/management/ModuleManagementServiceBean.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.core.command.service.management;
import dev.sheldan.abstracto.core.command.models.database.AModule;
import dev.sheldan.abstracto.core.command.model.database.AModule;
import dev.sheldan.abstracto.core.command.repository.ModuleRepository;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;

54
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/config/CreateAlias.java Normal file
View File

@@ -0,0 +1,54 @@
package dev.sheldan.abstracto.core.commands.config;
import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
import dev.sheldan.abstracto.core.command.config.HelpInfo;
import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.config.features.CoreFeatureDefinition;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.service.CommandInServerAliasService;
import dev.sheldan.abstracto.core.config.FeatureDefinition;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
@Component
public class CreateAlias extends AbstractConditionableCommand {
@Autowired
private CommandInServerAliasService aliasService;
@Override
public CommandResult execute(CommandContext commandContext) {
List<Object> parameters = commandContext.getParameters().getParameters();
String commandName = (String) parameters.get(0);
String aliasName = (String) parameters.get(1);
aliasService.createAliasForCommandInServer(commandContext.getGuild().getIdLong(), commandName, aliasName);
return CommandResult.fromSuccess();
}
@Override
public CommandConfiguration getConfiguration() {
Parameter commandNameParameter = Parameter.builder().name("commandName").type(String.class).templated(true).build();
Parameter aliasParameter = Parameter.builder().name("alias").type(String.class).templated(true).build();
List<Parameter> parameters = Arrays.asList(commandNameParameter, aliasParameter);
HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
return CommandConfiguration.builder()
.name("createAlias")
.module(ConfigModuleDefinition.CONFIG)
.parameters(parameters)
.templated(true)
.supportsEmbedException(true)
.help(helpInfo)
.causesReaction(true)
.build();
}
@Override
public FeatureDefinition getFeature() {
return CoreFeatureDefinition.CORE_FEATURE;
}
}

52
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/config/DeleteAlias.java Normal file
View File

@@ -0,0 +1,52 @@
package dev.sheldan.abstracto.core.commands.config;
import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
import dev.sheldan.abstracto.core.command.config.HelpInfo;
import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.config.features.CoreFeatureDefinition;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.service.CommandInServerAliasService;
import dev.sheldan.abstracto.core.config.FeatureDefinition;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
@Component
public class DeleteAlias extends AbstractConditionableCommand {
@Autowired
private CommandInServerAliasService aliasService;
@Override
public CommandResult execute(CommandContext commandContext) {
List<Object> parameters = commandContext.getParameters().getParameters();
String aliasName = (String) parameters.get(0);
aliasService.deleteCommandInServerAlias(commandContext.getGuild().getIdLong(), aliasName);
return CommandResult.fromSuccess();
}
@Override
public CommandConfiguration getConfiguration() {
Parameter aliasParameter = Parameter.builder().name("alias").type(String.class).templated(true).build();
List<Parameter> parameters = Arrays.asList(aliasParameter);
HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
return CommandConfiguration.builder()
.name("deleteAlias")
.module(ConfigModuleDefinition.CONFIG)
.parameters(parameters)
.templated(true)
.supportsEmbedException(true)
.help(helpInfo)
.causesReaction(true)
.build();
}
@Override
public FeatureDefinition getFeature() {
return CoreFeatureDefinition.CORE_FEATURE;
}
}

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/config/features/Allow.java
View File

@@ -7,7 +7,7 @@ import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.config.features.CoreFeatureDefinition;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.service.CommandService;
import dev.sheldan.abstracto.core.command.service.CommandServiceBean;
import dev.sheldan.abstracto.core.command.service.management.CommandManagementService;

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/config/features/AllowRole.java
View File

@@ -7,7 +7,7 @@ import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.config.features.CoreFeatureDefinition;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.service.CommandService;
import dev.sheldan.abstracto.core.command.service.CommandServiceBean;
import dev.sheldan.abstracto.core.command.service.management.CommandManagementService;

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/config/features/DisAllowRole.java
View File

@@ -7,7 +7,7 @@ import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.config.features.CoreFeatureDefinition;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.service.CommandService;
import dev.sheldan.abstracto.core.command.service.CommandServiceBean;
import dev.sheldan.abstracto.core.command.service.management.CommandManagementService;

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/config/features/MakeAffected.java
View File

@@ -7,7 +7,7 @@ import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.config.features.CoreFeatureDefinition;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.service.CommandService;
import dev.sheldan.abstracto.core.command.service.CommandServiceBean;
import dev.sheldan.abstracto.core.command.service.management.CommandManagementService;

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/config/features/MakeImmune.java
View File

@@ -7,7 +7,7 @@ import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.config.features.CoreFeatureDefinition;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.service.CommandService;
import dev.sheldan.abstracto.core.command.service.CommandServiceBean;
import dev.sheldan.abstracto.core.command.service.management.CommandManagementService;

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/config/features/Restrict.java
View File

@@ -7,7 +7,7 @@ import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.config.features.CoreFeatureDefinition;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.service.CommandService;
import dev.sheldan.abstracto.core.command.service.CommandServiceBean;
import dev.sheldan.abstracto.core.command.service.management.CommandManagementService;

56
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/help/Help.java
View File

@@ -6,8 +6,9 @@ import dev.sheldan.abstracto.core.command.config.features.CoreFeatureDefinition;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.execution.ContextConverter;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.models.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.service.CommandInServerAliasService;
import dev.sheldan.abstracto.core.command.service.CommandRegistry;
import dev.sheldan.abstracto.core.command.service.CommandService;
import dev.sheldan.abstracto.core.command.service.ModuleRegistry;
@@ -30,10 +31,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.*;
import java.util.concurrent.CompletableFuture;
@@ -69,6 +67,9 @@ public class Help implements Command {
@Autowired
private MetricService metricService;
@Autowired
private CommandInServerAliasService commandInServerAliasService;
public static final String HELP_COMMAND_EXECUTED_METRIC = "help.executions";
public static final String CATEGORY = "category";
private static final CounterMetric HELP_COMMAND_NO_PARAMETER_METRIC =
@@ -127,26 +128,31 @@ public class Help implements Command {
MessageToSend messageToSend = templateService.renderEmbedTemplate("help_module_details_response", model, commandContext.getGuild().getIdLong());
return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
.thenApply(aVoid -> CommandResult.fromIgnored());
} else if(commandRegistry.commandExists(parameter)) {
metricService.incrementCounter(HELP_COMMAND_COMMAND_METRIC);
Command command = commandRegistry.getCommandByName(parameter);
log.trace("Displaying help for command {}.", command.getConfiguration().getName());
ACommand aCommand = commandManagementService.findCommandByName(parameter);
ACommandInAServer aCommandInAServer = commandInServerManagementService.getCommandForServer(aCommand, commandContext.getGuild().getIdLong());
HelpCommandDetailsModel model = (HelpCommandDetailsModel) ContextConverter.fromCommandContext(commandContext, HelpCommandDetailsModel.class);
if(Boolean.TRUE.equals(aCommandInAServer.getRestricted())) {
model.setImmuneRoles(roleService.getRolesFromGuild(aCommandInAServer.getImmuneRoles()));
model.setAllowedRoles(roleService.getRolesFromGuild(aCommandInAServer.getAllowedRoles()));
model.setRestricted(true);
}
model.setUsage(commandService.generateUsage(command));
model.setCommand(command.getConfiguration());
MessageToSend messageToSend = templateService.renderEmbedTemplate("help_command_details_response", model, commandContext.getGuild().getIdLong());
return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
.thenApply(aVoid -> CommandResult.fromIgnored());
} else {
metricService.incrementCounter(HELP_COMMAND_WRONG_PARAM_METRIC);
return displayHelpOverview(commandContext);
Optional<Command> commandOptional = commandRegistry.getCommandByNameOptional(parameter, true, commandContext.getGuild().getIdLong());
if(commandOptional.isPresent()) {
metricService.incrementCounter(HELP_COMMAND_COMMAND_METRIC);
Command command = commandOptional.get();
log.trace("Displaying help for command {}.", command.getConfiguration().getName());
ACommand aCommand = commandManagementService.findCommandByName(command.getConfiguration().getName());
List<String> aliases = commandInServerAliasService.getAliasesForCommand(commandContext.getGuild().getIdLong(), command.getConfiguration().getName());
ACommandInAServer aCommandInAServer = commandInServerManagementService.getCommandForServer(aCommand, commandContext.getGuild().getIdLong());
HelpCommandDetailsModel model = (HelpCommandDetailsModel) ContextConverter.fromCommandContext(commandContext, HelpCommandDetailsModel.class);
model.setServerSpecificAliases(aliases);
if(Boolean.TRUE.equals(aCommandInAServer.getRestricted())) {
model.setImmuneRoles(roleService.getRolesFromGuild(aCommandInAServer.getImmuneRoles()));
model.setAllowedRoles(roleService.getRolesFromGuild(aCommandInAServer.getAllowedRoles()));
model.setRestricted(true);
}
model.setUsage(commandService.generateUsage(command));
model.setCommand(command.getConfiguration());
MessageToSend messageToSend = templateService.renderEmbedTemplate("help_command_details_response", model, commandContext.getGuild().getIdLong());
return FutureUtils.toSingleFutureGeneric(channelService.sendMessageToSendToChannel(messageToSend, commandContext.getChannel()))
.thenApply(aVoid -> CommandResult.fromIgnored());
} else {
metricService.incrementCounter(HELP_COMMAND_WRONG_PARAM_METRIC);
return displayHelpOverview(commandContext);
}
}
}
}

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/ChannelGroupServiceBean.java
View File

@@ -2,7 +2,7 @@ package dev.sheldan.abstracto.core.service;
import dev.sheldan.abstracto.core.command.exception.ChannelGroupNotFoundException;
import dev.sheldan.abstracto.core.command.exception.CommandNotFoundException;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.service.management.ChannelGroupCommandManagementService;
import dev.sheldan.abstracto.core.command.service.management.CommandManagementService;
import dev.sheldan.abstracto.core.models.database.AChannel;

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/LockServiceBean.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.core.service;
import dev.sheldan.abstracto.core.command.models.TableLocks;
import dev.sheldan.abstracto.core.command.model.TableLocks;
import dev.sheldan.abstracto.core.repository.LockRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

18
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/StartupServiceBean.java
View File

@@ -1,5 +1,8 @@
package dev.sheldan.abstracto.core.service;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.service.management.CommandInServerManagementService;
import dev.sheldan.abstracto.core.command.service.management.CommandManagementService;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AChannelType;
import dev.sheldan.abstracto.core.models.database.ARole;
@@ -43,6 +46,11 @@ public class StartupServiceBean implements Startup {
@Autowired
private RoleManagementService roleManagementService;
@Autowired
private CommandManagementService commandManagementService;
@Autowired
private CommandInServerManagementService commandInServerManagementService;
@Override
public void startBot() throws LoginException {
@@ -62,6 +70,7 @@ public class StartupServiceBean implements Startup {
JDA instance = service.getInstance();
List<Guild> onlineGuilds = instance.getGuilds();
Set<Long> availableServers = SnowflakeUtils.getSnowflakeIds(onlineGuilds);
List<ACommand> existingCommands = commandManagementService.getAllCommands();
availableServers.forEach(aLong -> {
AServer newAServer = serverManagementService.loadOrCreate(aLong);
Guild newGuild = instance.getGuildById(aLong);
@@ -69,11 +78,20 @@ public class StartupServiceBean implements Startup {
if(newGuild != null){
synchronizeRolesOf(newGuild, newAServer);
synchronizeChannelsOf(newGuild, newAServer);
synchronizeCommandsInServer(newAServer, existingCommands);
}
});
}
private void synchronizeCommandsInServer(AServer newAServer, List<ACommand> commands) {
commands.forEach(aCommand -> {
if(!commandInServerManagementService.doesCommandExistInServer(aCommand, newAServer)) {
commandInServerManagementService.createCommandInServer(aCommand, newAServer);
}
});
}
private void synchronizeRolesOf(Guild guild, AServer existingAServer){
List<Role> guildRoles = guild.getRoles();
List<ARole> existingRoles = existingAServer.getRoles();

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/management/ChannelManagementServiceBean.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.core.service.management;
import dev.sheldan.abstracto.core.command.models.TableLocks;
import dev.sheldan.abstracto.core.command.model.TableLocks;
import dev.sheldan.abstracto.core.exception.ChannelNotFoundException;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AChannelType;

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/management/UserInServerManagementServiceBean.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.core.service.management;
import dev.sheldan.abstracto.core.command.models.TableLocks;
import dev.sheldan.abstracto.core.command.model.TableLocks;
import dev.sheldan.abstracto.core.exception.UserInServerNotFoundException;
import dev.sheldan.abstracto.core.models.ServerUser;
import dev.sheldan.abstracto.core.models.database.AServer;

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/management/UserManagementServiceBean.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.core.service.management;
import dev.sheldan.abstracto.core.command.models.TableLocks;
import dev.sheldan.abstracto.core.command.model.TableLocks;
import dev.sheldan.abstracto.core.models.database.AUser;
import dev.sheldan.abstracto.core.repository.UserRepository;
import dev.sheldan.abstracto.core.service.LockService;

11
abstracto-application/core/core-impl/src/main/resources/migrations/1.2.5-core/collection.xml Normal file
View File

@@ -0,0 +1,11 @@
<?xml version="1.1" encoding="UTF-8" standalone="no"?>
<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
xmlns:pro="http://www.liquibase.org/xml/ns/pro"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog ../dbchangelog-3.8.xsd
http://www.liquibase.org/xml/ns/dbchangelog-ext ../dbchangelog-3.8.xsd
http://www.liquibase.org/xml/ns/pro ../dbchangelog-3.8.xsd" >
<include file="core-tables/tables.xml" relativeToChangelogFile="true"/>
<include file="core-seedData/data.xml" relativeToChangelogFile="true"/>
</databaseChangeLog>

23
abstracto-application/core/core-impl/src/main/resources/migrations/1.2.5-core/core-seedData/command.xml Normal file
View File

@@ -0,0 +1,23 @@
<?xml version="1.1" encoding="UTF-8" standalone="no"?>
<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
xmlns:pro="http://www.liquibase.org/xml/ns/pro"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog ../../dbchangelog-3.8.xsd
http://www.liquibase.org/xml/ns/dbchangelog-ext ../../dbchangelog-3.8.xsd
http://www.liquibase.org/xml/ns/pro ../../dbchangelog-3.8.xsd" >
<property name="coreFeature" value="(SELECT id FROM feature WHERE key = 'core')"/>
<property name="configModule" value="(SELECT id FROM module WHERE name = 'config')"/>
<changeSet author="Sheldan" id="createAlias-command" >
<insert tableName="command">
<column name="name" value="createAlias"/>
<column name="module_id" valueComputed="${configModule}"/>
<column name="feature_id" valueComputed="${coreFeature}"/>
</insert>
<insert tableName="command">
<column name="name" value="deleteAlias"/>
<column name="module_id" valueComputed="${configModule}"/>
<column name="feature_id" valueComputed="${coreFeature}"/>
</insert>
</changeSet>
</databaseChangeLog>

10
abstracto-application/core/core-impl/src/main/resources/migrations/1.2.5-core/core-seedData/data.xml Normal file
View File

@@ -0,0 +1,10 @@
<?xml version="1.1" encoding="UTF-8" standalone="no"?>
<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
xmlns:pro="http://www.liquibase.org/xml/ns/pro"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog ../../dbchangelog-3.8.xsd
http://www.liquibase.org/xml/ns/dbchangelog-ext ../../dbchangelog-3.8.xsd
http://www.liquibase.org/xml/ns/pro ../../dbchangelog-3.8.xsd" >
<include file="command.xml" relativeToChangelogFile="true"/>
</databaseChangeLog>

29
abstracto-application/core/core-impl/src/main/resources/migrations/1.2.5-core/core-tables/command_in_server_alias.xml Normal file
View File

@@ -0,0 +1,29 @@
<?xml version="1.1" encoding="UTF-8" standalone="no"?>
<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
xmlns:pro="http://www.liquibase.org/xml/ns/pro"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog ../../dbchangelog-3.8.xsd
http://www.liquibase.org/xml/ns/dbchangelog-ext ../../dbchangelog-3.8.xsd
http://www.liquibase.org/xml/ns/pro ../../dbchangelog-3.8.xsd" >
<changeSet author="Sheldan" id="command_in_server_alias-table">
<createTable tableName="command_in_server_alias">
<column name="command_in_server_id" type="BIGINT">
<constraints nullable="false"/>
</column>
<column name="name" type="VARCHAR(255)">
<constraints nullable="false"/>
</column>
<column name="created" type="TIMESTAMP WITHOUT TIME ZONE">
<constraints nullable="true"/>
</column>
</createTable>
<addPrimaryKey columnNames="command_in_server_id, name" tableName="command_in_server_alias" constraintName="pk_command_in_server_alias" validate="true"/>
<addForeignKeyConstraint baseColumnNames="command_in_server_id" baseTableName="command_in_server_alias" constraintName="fk_command_in_server_alias_command_in_server" deferrable="false" initiallyDeferred="false" onDelete="NO ACTION" onUpdate="NO ACTION" referencedColumnNames="command_in_server_id" referencedTableName="command_in_server" validate="true"/>
<sql>
DROP TRIGGER IF EXISTS command_in_server_alias_insert_trigger ON command_in_server_alias;
CREATE TRIGGER command_in_server_alias_insert_trigger BEFORE INSERT ON command_in_server_alias FOR EACH ROW EXECUTE PROCEDURE insert_trigger_procedure();
</sql>
</changeSet>
</databaseChangeLog>

10
abstracto-application/core/core-impl/src/main/resources/migrations/1.2.5-core/core-tables/tables.xml Normal file
View File

@@ -0,0 +1,10 @@
<?xml version="1.1" encoding="UTF-8" standalone="no"?>
<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
xmlns:pro="http://www.liquibase.org/xml/ns/pro"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog ../../dbchangelog-3.8.xsd
http://www.liquibase.org/xml/ns/dbchangelog-ext ../../dbchangelog-3.8.xsd
http://www.liquibase.org/xml/ns/pro ../../dbchangelog-3.8.xsd" >
<include file="command_in_server_alias.xml" relativeToChangelogFile="true"/>
</databaseChangeLog>

1
abstracto-application/core/core-impl/src/main/resources/migrations/core-changeLog.xml
View File

@@ -10,4 +10,5 @@
<include file="1.0-templating/collection.xml" relativeToChangelogFile="true"/>
<include file="1.1-core/collection.xml" relativeToChangelogFile="true"/>
<include file="1.2-core/collection.xml" relativeToChangelogFile="true"/>
<include file="1.2.5-core/collection.xml" relativeToChangelogFile="true"/>
</databaseChangeLog>

4
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/ChannelGroupCommandServiceBeanTest.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.core.command.service;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.service.management.ChannelGroupCommandManagementService;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AChannelGroup;
@@ -11,9 +11,7 @@ import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.ArrayList;
import java.util.Arrays;

152
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/CommandInServerAliasServiceBeanTest.java Normal file
View File

@@ -0,0 +1,152 @@
package dev.sheldan.abstracto.core.command.service;
import dev.sheldan.abstracto.core.command.Command;
import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
import dev.sheldan.abstracto.core.command.exception.CommandAliasAlreadyExistsException;
import dev.sheldan.abstracto.core.command.exception.CommandAliasDoesNotExistsException;
import dev.sheldan.abstracto.core.command.exception.CommandAliasHidesCommandException;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.model.database.ACommandInServerAlias;
import dev.sheldan.abstracto.core.command.model.database.CommandInServerAliasId;
import dev.sheldan.abstracto.core.command.service.management.CommandInServerAliasManagementServiceBean;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class CommandInServerAliasServiceBeanTest {
@InjectMocks
private CommandInServerAliasServiceBean testUnit;
@Mock
private CommandInServerAliasManagementServiceBean commandInServerAliasManagementServiceBean;
@Mock
private ServerManagementService serverManagementService;
@Mock
private CommandInServerService commandInServerService;
@Mock
private CommandRegistry commandRegistry;
@Mock
private AServer server;
@Mock
private ACommandInServerAlias alias;
@Mock
private ACommandInAServer aCommandInAServer;
@Mock
private Command command;
private static final Long SERVER_ID = 1L;
private static final String COMMAND_NAME = "command";
private static final String ALIAS_NAME = "alias";
@Test
public void testCreateAlias() {
when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
when(commandInServerAliasManagementServiceBean.getCommandInServerAlias(server, ALIAS_NAME)).thenReturn(Optional.empty());
when(commandRegistry.getCommandByNameOptional(ALIAS_NAME, false, SERVER_ID)).thenReturn(Optional.empty());
when(commandInServerService.getCommandInAServer(server, COMMAND_NAME)).thenReturn(aCommandInAServer);
when(commandInServerAliasManagementServiceBean.createAliasForCommand(aCommandInAServer, ALIAS_NAME)).thenReturn(alias);
ACommandInServerAlias createdAlias = testUnit.createAliasForCommandInServer(SERVER_ID, COMMAND_NAME, ALIAS_NAME);
Assert.assertEquals(alias, createdAlias);
}
@Test(expected = CommandAliasAlreadyExistsException.class)
public void testCreateAliasAlreadyExists() {
when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
when(commandInServerAliasManagementServiceBean.getCommandInServerAlias(server, ALIAS_NAME)).thenReturn(Optional.of(alias));
ACommandInAServer commandInAServer = Mockito.mock(ACommandInAServer.class);
when(alias.getCommandInAServer()).thenReturn(commandInAServer);
ACommand command = Mockito.mock(ACommand.class);
when(commandInAServer.getCommandReference()).thenReturn(command);
when(command.getName()).thenReturn(COMMAND_NAME);
testUnit.createAliasForCommandInServer(SERVER_ID, COMMAND_NAME, ALIAS_NAME);
}
@Test(expected = CommandAliasHidesCommandException.class)
public void testCreateAliasForCommandName() {
when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
when(commandInServerAliasManagementServiceBean.getCommandInServerAlias(server, ALIAS_NAME)).thenReturn(Optional.empty());
when(commandRegistry.getCommandByNameOptional(ALIAS_NAME, false, SERVER_ID)).thenReturn(Optional.of(command));
CommandConfiguration config = Mockito.mock(CommandConfiguration.class);
when(command.getConfiguration()).thenReturn(config);
when(config.getName()).thenReturn(COMMAND_NAME);
testUnit.createAliasForCommandInServer(SERVER_ID, COMMAND_NAME, ALIAS_NAME);
}
@Test
public void testGetCommandInServerAliasExisting() {
when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
when(commandInServerAliasManagementServiceBean.getCommandInServerAlias(server, ALIAS_NAME)).thenReturn(Optional.of(alias));
Optional<ACommandInServerAlias> optional = testUnit.getCommandInServerAlias(SERVER_ID, ALIAS_NAME);
Assert.assertTrue(optional.isPresent());
optional.ifPresent(returnedAlias ->
Assert.assertEquals(alias, returnedAlias)
);
}
@Test
public void testGetCommandInServerAliasNotExisting() {
when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
when(commandInServerAliasManagementServiceBean.getCommandInServerAlias(server, ALIAS_NAME)).thenReturn(Optional.empty());
Optional<ACommandInServerAlias> optional = testUnit.getCommandInServerAlias(SERVER_ID, ALIAS_NAME);
Assert.assertFalse(optional.isPresent());
}
@Test
public void testDeleteCommandInServerAlias() {
when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
when(commandInServerAliasManagementServiceBean.getCommandInServerAlias(server, ALIAS_NAME)).thenReturn(Optional.of(alias));
testUnit.deleteCommandInServerAlias(SERVER_ID, ALIAS_NAME);
verify(commandInServerAliasManagementServiceBean, times(1)).deleteCommandInServerAlias(alias);
}
@Test(expected = CommandAliasDoesNotExistsException.class)
public void testDeleteCommandInServerAliasNotExisting() {
when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
when(commandInServerAliasManagementServiceBean.getCommandInServerAlias(server, ALIAS_NAME)).thenReturn(Optional.empty());
testUnit.deleteCommandInServerAlias(SERVER_ID, ALIAS_NAME);
}
@Test
public void testGetAliasesForCommandNoResults() {
when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
when(commandInServerAliasManagementServiceBean.getAliasesForCommandInServer(server, COMMAND_NAME)).thenReturn(new ArrayList<>());
List<String> aliases = testUnit.getAliasesForCommand(SERVER_ID, COMMAND_NAME);
Assert.assertEquals(0, aliases.size());
}
@Test
public void testGetAliasesForCommandWithResults() {
when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
when(commandInServerAliasManagementServiceBean.getAliasesForCommandInServer(server, COMMAND_NAME)).thenReturn(Arrays.asList(alias));
CommandInServerAliasId id = Mockito.mock(CommandInServerAliasId.class);
when(alias.getAliasId()).thenReturn(id);
when(id.getName()).thenReturn(ALIAS_NAME);
List<String> aliases = testUnit.getAliasesForCommand(SERVER_ID, COMMAND_NAME);
Assert.assertEquals(1, aliases.size());
Assert.assertEquals(ALIAS_NAME, aliases.get(0));
}
}

62
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/CommandInServerServiceBeanTest.java Normal file
View File

@@ -0,0 +1,62 @@
package dev.sheldan.abstracto.core.command.service;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.service.management.CommandInServerManagementService;
import dev.sheldan.abstracto.core.command.service.management.CommandManagementService;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class CommandInServerServiceBeanTest {
@InjectMocks
private CommandInServerServiceBean testUnit;
@Mock
private CommandManagementService commandManagementService;
@Mock
private ServerManagementService serverManagementService;
@Mock
private CommandInServerManagementService commandInServerManagementService;
@Mock
private AServer server;
@Mock
private ACommand command;
@Mock
private ACommandInAServer commandInAServer;
private static final Long SERVER_ID = 4L;
private static final String COMMAND_NAME = "command";
@Test
public void testGetCommandInAServerWithId() {
when(serverManagementService.loadServer(SERVER_ID)).thenReturn(server);
when(commandManagementService.findCommandByName(COMMAND_NAME)).thenReturn(command);
when(commandInServerManagementService.getCommandForServer(command, server)).thenReturn(commandInAServer);
ACommandInAServer foundCommandInServer = testUnit.getCommandInAServer(SERVER_ID, COMMAND_NAME);
Assert.assertEquals(commandInAServer, foundCommandInServer);
}
@Test
public void testGetCommandInAServer() {
when(commandManagementService.findCommandByName(COMMAND_NAME)).thenReturn(command);
when(commandInServerManagementService.getCommandForServer(command, server)).thenReturn(commandInAServer);
ACommandInAServer foundCommandInServer = testUnit.getCommandInAServer(server, COMMAND_NAME);
Assert.assertEquals(commandInAServer, foundCommandInServer);
}
}

337
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/CommandManagerTest.java Normal file
View File

@@ -0,0 +1,337 @@
package dev.sheldan.abstracto.core.command.service;
import dev.sheldan.abstracto.core.command.Command;
import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
import dev.sheldan.abstracto.core.command.config.ModuleDefinition;
import dev.sheldan.abstracto.core.command.config.ModuleInfo;
import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.exception.CommandNotFoundException;
import dev.sheldan.abstracto.core.command.exception.InsufficientParametersException;
import dev.sheldan.abstracto.core.command.execution.UnParsedCommandParameter;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.model.database.ACommandInServerAlias;
import dev.sheldan.abstracto.core.metric.service.MetricService;
import dev.sheldan.abstracto.core.models.property.SystemConfigProperty;
import dev.sheldan.abstracto.core.service.ConfigService;
import dev.sheldan.abstracto.core.service.management.DefaultConfigManagementService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Message;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.*;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import static dev.sheldan.abstracto.core.command.service.CommandManager.PREFIX;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class CommandManagerTest {
public static final String DEFAULT_PREFIX = "!";
@InjectMocks
private CommandManager testUnit;
@Mock
private ConfigService configService;
@Mock
private DefaultConfigManagementService defaultConfigManagementService;
@Mock
private MetricService metricService;
@Mock
private CommandInServerAliasService commandInServerAliasService;
@Mock
private ServerManagementService serverManagementService;
@Spy
private List<Command> commands = new ArrayList<>();
@Mock
private Command firstCommand;
@Mock
private CommandConfiguration commandConfiguration;
@Mock
private UnParsedCommandParameter parsedCommandParameter;
@Mock
private Parameter parameter;
@Mock
private ACommandInServerAlias alias;
@Mock
private ACommandInAServer commandInAServer;
@Mock
private ACommand aCommand;
private static final String COMMAND_NAME = "name";
private static final String COMMAND_NAME_2 = COMMAND_NAME + "suffix";
private static final String ALIAS_NAME = "name2";
private static final Long SERVER_ID = 1L;
@Before
public void init() {
MockitoAnnotations.initMocks(this);
}
@Test(expected = CommandNotFoundException.class)
public void testFindByParametersNoCommands(){
when(commandInServerAliasService.getCommandInServerAlias(SERVER_ID, COMMAND_NAME)).thenReturn(Optional.empty());
testUnit.findCommandByParameters(COMMAND_NAME, parsedCommandParameter, SERVER_ID);
}
@Test
public void testFindByParametersViaCommandNameNecessaryParameter() {
commands.add(firstCommand);
when(commandConfiguration.getName()).thenReturn(COMMAND_NAME);
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
when(commandConfiguration.getNecessaryParameterCount()).thenReturn(0);
when(parsedCommandParameter.getParameters()).thenReturn(new ArrayList<>());
Command foundCommand = testUnit.findCommandByParameters(COMMAND_NAME, parsedCommandParameter, SERVER_ID);
Assert.assertEquals(firstCommand, foundCommand);
}
@Test
public void testFindByParametersViaCommandNameNoParameters() {
commands.add(firstCommand);
when(commandConfiguration.getName()).thenReturn(COMMAND_NAME);
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
when(commandConfiguration.getParameters()).thenReturn(null);
Command foundCommand = testUnit.findCommandByParameters(COMMAND_NAME, parsedCommandParameter, SERVER_ID);
Assert.assertEquals(firstCommand, foundCommand);
}
@Test
public void testFindByParametersViaCommandNameNoParametersButParametersGiven() {
commands.add(firstCommand);
when(commandConfiguration.getName()).thenReturn(COMMAND_NAME);
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
when(commandConfiguration.getParameters()).thenReturn(null);
Command foundCommand = testUnit.findCommandByParameters(COMMAND_NAME, parsedCommandParameter, SERVER_ID);
Assert.assertEquals(firstCommand, foundCommand);
}
@Test
public void testFindByParametersViaCommandAliasAdequateParameter() {
commands.add(firstCommand);
when(commandConfiguration.getName()).thenReturn(COMMAND_NAME_2);
when(commandConfiguration.getAliases()).thenReturn(Arrays.asList(COMMAND_NAME));
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
when(commandConfiguration.getNecessaryParameterCount()).thenReturn(0);
when(parsedCommandParameter.getParameters()).thenReturn(new ArrayList<>());
Command foundCommand = testUnit.findCommandByParameters(COMMAND_NAME, parsedCommandParameter, SERVER_ID);
Assert.assertEquals(firstCommand, foundCommand);
}
@Test(expected = InsufficientParametersException.class)
public void testFindByParametersViaCommandNameInsufficientParameters() {
commands.add(firstCommand);
when(commandConfiguration.getParameters()).thenReturn(Arrays.asList(parameter));
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
when(commandConfiguration.getName()).thenReturn(COMMAND_NAME);
when(commandConfiguration.getNecessaryParameterCount()).thenReturn(1);
when(parsedCommandParameter.getParameters()).thenReturn(new ArrayList<>());
testUnit.findCommandByParameters(COMMAND_NAME, parsedCommandParameter, SERVER_ID);
}
@Test
public void testFindByParametersViaServerAliasAdequateParameter() {
commands.add(firstCommand);
when(commandConfiguration.getName()).thenReturn(COMMAND_NAME);
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
when(commandConfiguration.getNecessaryParameterCount()).thenReturn(0);
when(parsedCommandParameter.getParameters()).thenReturn(new ArrayList<>());
setupAliasTest();
Command foundCommand = testUnit.findCommandByParameters(ALIAS_NAME, parsedCommandParameter, SERVER_ID);
Assert.assertEquals(firstCommand, foundCommand);
}
@Test
public void testFindCommandViaName() {
commands.add(firstCommand);
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
when(commandConfiguration.getName()).thenReturn(COMMAND_NAME);
Command foundName = testUnit.findCommandViaName(COMMAND_NAME);
Assert.assertEquals(firstCommand, foundName);
}
@Test(expected = CommandNotFoundException.class)
public void testFindCommandViaNameNotFound() {
commands.add(firstCommand);
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
when(commandConfiguration.getName()).thenReturn(COMMAND_NAME_2);
testUnit.findCommandViaName(COMMAND_NAME);
}
@Test
public void testIsCommand() {
Message message = setupIsCommandScenario();
when(message.getContentRaw()).thenReturn("!com");
Assert.assertTrue(testUnit.isCommand(message));
}
@Test
public void testIsCommandNoneFound() {
Message message = setupIsCommandScenario();
when(message.getContentRaw()).thenReturn("com");
Assert.assertFalse(testUnit.isCommand(message));
}
@Test
public void testGetCommand() {
setupPrefix();
String foundCommandName = testUnit.getCommandName("!com", SERVER_ID);
Assert.assertEquals("com", foundCommandName);
}
@Test
public void testGetCommandByNameWithoutAlias() {
commands.add(firstCommand);
when(commandConfiguration.getName()).thenReturn(COMMAND_NAME);
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
Command foundCommand = testUnit.getCommandByName(COMMAND_NAME, false, SERVER_ID);
Assert.assertEquals(firstCommand, foundCommand);
}
@Test
public void testGetCommandByNameOptionalWithoutAlias() {
commands.add(firstCommand);
when(commandConfiguration.getName()).thenReturn(COMMAND_NAME);
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
Optional<Command> foundCommandOptional = testUnit.getCommandByNameOptional(COMMAND_NAME, false, SERVER_ID);
Assert.assertTrue(foundCommandOptional.isPresent());
foundCommandOptional.ifPresent(command -> {
Assert.assertEquals(firstCommand, foundCommandOptional.get());
});
}
@Test
public void testGetCommandByNameNotFoundWithoutAlias() {
commands.add(firstCommand);
when(commandConfiguration.getName()).thenReturn(COMMAND_NAME_2);
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
Command foundCommand = testUnit.getCommandByName(COMMAND_NAME, false, SERVER_ID);
Assert.assertNull(foundCommand);
}
@Test
public void testGetCommandByNameViaAlias() {
commands.add(firstCommand);
when(commandConfiguration.getName()).thenReturn(COMMAND_NAME);
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
setupAliasTest();
Command foundCommand = testUnit.getCommandByName(ALIAS_NAME, true, SERVER_ID);
Assert.assertEquals(firstCommand, foundCommand);
}
@Test
public void testGetCommandByNameViaAliasNotFound() {
commands.add(firstCommand);
when(commandConfiguration.getName()).thenReturn(COMMAND_NAME);
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
Command foundCommand = testUnit.getCommandByName(ALIAS_NAME, true, SERVER_ID);
Assert.assertNull(foundCommand);
}
@Test
public void testCommandExistsWithoutAlias() {
commands.add(firstCommand);
when(commandConfiguration.getName()).thenReturn(COMMAND_NAME);
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
Assert.assertTrue(testUnit.commandExists(COMMAND_NAME, false, SERVER_ID));
}
@Test
public void testCommandExistsWithoutAliasNotFound() {
commands.add(firstCommand);
when(commandConfiguration.getName()).thenReturn(COMMAND_NAME_2);
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
Assert.assertFalse(testUnit.commandExists(COMMAND_NAME, false, SERVER_ID));
}
@Test
public void testCommandExistsWithAlias() {
commands.add(firstCommand);
when(commandConfiguration.getName()).thenReturn(COMMAND_NAME);
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
setupAliasTest();
Assert.assertTrue(testUnit.commandExists(COMMAND_NAME, true, SERVER_ID));
}
@Test
public void testCommandExistsWithAliasNotFound() {
commands.add(firstCommand);
when(commandConfiguration.getName()).thenReturn(COMMAND_NAME_2);
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
setupAliasTest();
Assert.assertFalse(testUnit.commandExists(COMMAND_NAME, true, SERVER_ID));
}
@Test
public void testGetAllCommandsFromModuleOneCommandFound() {
ModuleDefinition moduleDefinition = Mockito.mock(ModuleDefinition.class);
ModuleInfo info = Mockito.mock(ModuleInfo.class);
String moduleName = "module";
when(info.getName()).thenReturn(moduleName);
when(moduleDefinition.getInfo()).thenReturn(info);
when(commandConfiguration.getModule()).thenReturn(moduleName);
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
commands.add(firstCommand);
List<Command> foundCommands = testUnit.getAllCommandsFromModule(moduleDefinition);
Assert.assertEquals(1, foundCommands.size());
Assert.assertEquals(firstCommand, foundCommands.get(0));
}
@Test
public void testGetAllCommandsFromModuleNoCommandFound() {
ModuleDefinition moduleDefinition = Mockito.mock(ModuleDefinition.class);
ModuleInfo info = Mockito.mock(ModuleInfo.class);
String moduleName = "module";
when(info.getName()).thenReturn(moduleName);
when(moduleDefinition.getInfo()).thenReturn(info);
when(commandConfiguration.getModule()).thenReturn(moduleName + "2");
when(firstCommand.getConfiguration()).thenReturn(commandConfiguration);
commands.add(firstCommand);
List<Command> foundCommands = testUnit.getAllCommandsFromModule(moduleDefinition);
Assert.assertEquals(0, foundCommands.size());
}
private void setupAliasTest() {
when(commandInServerAliasService.getCommandInServerAlias(SERVER_ID, ALIAS_NAME)).thenReturn(Optional.of(alias));
when(alias.getCommandInAServer()).thenReturn(commandInAServer);
when(commandInAServer.getCommandReference()).thenReturn(aCommand);
when(aCommand.getName()).thenReturn(COMMAND_NAME);
}
private Message setupIsCommandScenario() {
Message message = Mockito.mock(Message.class);
setupPrefix();
Guild guild = Mockito.mock(Guild.class);
when(message.getGuild()).thenReturn(guild);
when(guild.getIdLong()).thenReturn(SERVER_ID);
return message;
}
private void setupPrefix() {
SystemConfigProperty defaultConfig = Mockito.mock(SystemConfigProperty.class);
when(defaultConfig.getStringValue()).thenReturn(DEFAULT_PREFIX);
when(defaultConfigManagementService.getDefaultConfig(PREFIX)).thenReturn(defaultConfig);
when(configService.getStringValue(PREFIX, SERVER_ID, DEFAULT_PREFIX)).thenReturn(DEFAULT_PREFIX);
}
}

102
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/service/management/CommandInServerAliasManagementServiceBeanTest.java Normal file
View File

@@ -0,0 +1,102 @@
package dev.sheldan.abstracto.core.command.service.management;
import dev.sheldan.abstracto.core.command.model.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.model.database.ACommandInServerAlias;
import dev.sheldan.abstracto.core.command.repository.CommandInServerAliasRepository;
import dev.sheldan.abstracto.core.models.database.AServer;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import static org.mockito.Mockito.*;
@RunWith(MockitoJUnitRunner.class)
public class CommandInServerAliasManagementServiceBeanTest {
@InjectMocks
private CommandInServerAliasManagementServiceBean testUnit;
@Mock
private CommandInServerAliasRepository repository;
@Mock
private ACommandInServerAlias alias;
@Mock
private AServer server;
private static final String ALIAS_NAME = "alias";
private static final String COMMAND_NAME = "command";
@Test
public void testGetAliasesInServer() {
when(repository.findByCommandInAServer_ServerReference(server)).thenReturn(Arrays.asList(alias));
List<ACommandInServerAlias> foundAliases = testUnit.getAliasesInServer(server);
Assert.assertEquals(1, foundAliases.size());
Assert.assertEquals(alias, foundAliases.get(0));
}
@Test
public void testDoesCommandInServerAliasExist() {
when(repository.existsByCommandInAServer_ServerReferenceAndAliasId_NameEqualsIgnoreCase(server, ALIAS_NAME)).thenReturn(true);
Assert.assertTrue(testUnit.doesCommandInServerAliasExist(server, ALIAS_NAME));
}
@Test
public void testDoesCommandInServerAliasNotExist() {
when(repository.existsByCommandInAServer_ServerReferenceAndAliasId_NameEqualsIgnoreCase(server, ALIAS_NAME)).thenReturn(false);
Assert.assertFalse(testUnit.doesCommandInServerAliasExist(server, ALIAS_NAME));
}
@Test
public void testGetCommandInServerAlias() {
when(repository.findByCommandInAServer_ServerReferenceAndAliasId_NameEqualsIgnoreCase(server, ALIAS_NAME)).thenReturn(Optional.of(alias));
Optional<ACommandInServerAlias> commandOptional = testUnit.getCommandInServerAlias(server, ALIAS_NAME);
Assert.assertTrue(commandOptional.isPresent());
commandOptional.ifPresent(existingAlias ->
Assert.assertEquals(alias, existingAlias)
);
}
@Test
public void testGetCommandInServerAliasNotExist() {
when(repository.findByCommandInAServer_ServerReferenceAndAliasId_NameEqualsIgnoreCase(server, ALIAS_NAME)).thenReturn(Optional.empty());
Optional<ACommandInServerAlias> commandOptional = testUnit.getCommandInServerAlias(server, ALIAS_NAME);
Assert.assertFalse(commandOptional.isPresent());
}
@Test
public void testCreateAliasForCommand() {
ACommandInAServer commandInAServer = Mockito.mock(ACommandInAServer.class);
ArgumentCaptor<ACommandInServerAlias> aliasArgumentCaptor = ArgumentCaptor.forClass(ACommandInServerAlias.class);
ACommandInServerAlias savedAlias = Mockito.mock(ACommandInServerAlias.class);
when(repository.save(aliasArgumentCaptor.capture())).thenReturn(savedAlias);
ACommandInServerAlias createdAlias = testUnit.createAliasForCommand(commandInAServer, ALIAS_NAME);
Assert.assertEquals(savedAlias, createdAlias);
ACommandInServerAlias capturedAlias = aliasArgumentCaptor.getValue();
Assert.assertEquals(commandInAServer, capturedAlias.getCommandInAServer());
}
@Test
public void testDeleteCommandInServerAlias() {
testUnit.deleteCommandInServerAlias(alias);
verify(repository, times(1)).delete(alias);
}
@Test
public void testGetAliasesForCommandInServer() {
when(repository.findByCommandInAServer_ServerReferenceAndCommandInAServer_CommandReference_NameEqualsIgnoreCase(server, COMMAND_NAME)).thenReturn(Arrays.asList(alias));
List<ACommandInServerAlias> foundAliases = testUnit.getAliasesForCommandInServer(server, COMMAND_NAME);
Assert.assertEquals(1, foundAliases.size());
Assert.assertEquals(alias, foundAliases.get(0));
}
}

11
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/service/management/AllowedMentionManagementServiceBeanTest.java
View File

@@ -9,6 +9,7 @@ import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Optional;
@@ -67,11 +68,13 @@ public class AllowedMentionManagementServiceBeanTest {
@Test
public void createCustomAllowedMention() {
when(serverManagementService.loadOrCreate(SERVER_ID)).thenReturn(server);
AllowedMention createdMention = testUnit.createCustomAllowedMention(SERVER_ID, allowedMention);
ArgumentCaptor<AllowedMention> mentionCaptor = ArgumentCaptor.forClass(AllowedMention.class);
verify(allowedMentionRepository, times(1)).save(mentionCaptor.capture());
Assert.assertEquals(createdMention, mentionCaptor.getValue());
Assert.assertEquals(server, createdMention.getServer());
AllowedMention toReturn = Mockito.mock(AllowedMention.class);
when(allowedMentionRepository.save(mentionCaptor.capture())).thenReturn(toReturn);
AllowedMention createdMention = testUnit.createCustomAllowedMention(SERVER_ID, allowedMention);
Assert.assertEquals(toReturn, createdMention);
AllowedMention usedValue = mentionCaptor.getValue();
Assert.assertEquals(server, usedValue.getServer());
}
@Test

29
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/service/management/FeatureModeManagementServiceBeanTest.java
View File

@@ -6,6 +6,8 @@ import dev.sheldan.abstracto.core.repository.FeatureModeRepository;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
@@ -43,29 +45,36 @@ public class FeatureModeManagementServiceBeanTest {
@Mock
private AFeatureMode aFeatureMode;
@Captor
private ArgumentCaptor<AFeatureMode> modeCaptor;
private static final String FEATURE_MODE = "featureMode";
@Test
public void createModeWithModeAsString() {
when(featureFlag.getServer()).thenReturn(server);
when(featureModeRepository.save(modeCaptor.capture())).thenReturn(aFeatureMode);
AFeatureMode createdMode = testUnit.createMode(featureFlag, FEATURE_MODE, true);
Assert.assertEquals(true, createdMode.getEnabled());
Assert.assertEquals(featureFlag, createdMode.getFeatureFlag());
Assert.assertEquals(FEATURE_MODE, createdMode.getFeatureMode());
Assert.assertEquals(server, createdMode.getServer());
verify(featureModeRepository, times(1)).save(createdMode);
AFeatureMode createdValue = modeCaptor.getValue();
Assert.assertEquals(aFeatureMode, createdMode);
Assert.assertEquals(true, createdValue.getEnabled());
Assert.assertEquals(featureFlag, createdValue.getFeatureFlag());
Assert.assertEquals(FEATURE_MODE, createdValue.getFeatureMode());
Assert.assertEquals(server, createdValue.getServer());
}
@Test
public void testCreateMode() {
when(featureFlag.getServer()).thenReturn(server);
when(featureMode.getKey()).thenReturn(FEATURE_MODE);
when(featureModeRepository.save(modeCaptor.capture())).thenReturn(aFeatureMode);
AFeatureMode createdMode = testUnit.createMode(featureFlag, featureMode, true);
Assert.assertEquals(true, createdMode.getEnabled());
Assert.assertEquals(featureFlag, createdMode.getFeatureFlag());
Assert.assertEquals(FEATURE_MODE, createdMode.getFeatureMode());
Assert.assertEquals(server, createdMode.getServer());
verify(featureModeRepository, times(1)).save(createdMode);
AFeatureMode createdValue = modeCaptor.getValue();
Assert.assertEquals(aFeatureMode, createdMode);
Assert.assertEquals(true, createdValue.getEnabled());
Assert.assertEquals(featureFlag, createdValue.getFeatureFlag());
Assert.assertEquals(FEATURE_MODE, createdValue.getFeatureMode());
Assert.assertEquals(server, createdValue.getServer());
}
@Test

19
abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/templating/service/management/TemplateManagementServiceBeanTest.java
View File

@@ -5,6 +5,8 @@ import dev.sheldan.abstracto.core.templating.repository.TemplateRepository;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
@@ -24,6 +26,12 @@ public class TemplateManagementServiceBeanTest {
@Mock
private TemplateRepository repository;
@Mock
private Template template;
@Captor
private ArgumentCaptor<Template> templateArgumentCaptor;
private static final String TEMPLATE_KEY = "templateKey";
private static final String TEMPLATE_SOURCE = "source";
@@ -53,11 +61,14 @@ public class TemplateManagementServiceBeanTest {
@Test
public void testCreateTemplate() {
Template template = templateManagementServiceBean.createTemplate(TEMPLATE_KEY, TEMPLATE_SOURCE);
Assert.assertEquals(template.getContent(), TEMPLATE_SOURCE);
Assert.assertEquals(template.getKey(), TEMPLATE_KEY);
when(repository.save(templateArgumentCaptor.capture())).thenReturn(template);
Template createdTemplate = templateManagementServiceBean.createTemplate(TEMPLATE_KEY, TEMPLATE_SOURCE);
Template savedTemplate = templateArgumentCaptor.getValue();
Assert.assertEquals(template, createdTemplate);
Assert.assertEquals(TEMPLATE_SOURCE, savedTemplate.getContent());
Assert.assertEquals(TEMPLATE_KEY, savedTemplate.getKey());
verify(repository, times(1)).save(any(Template.class));
Assert.assertTrue(Duration.between(template.getLastModified(), Instant.now()).getSeconds() < 1);
Assert.assertTrue(Duration.between(savedTemplate.getLastModified(), Instant.now()).getSeconds() < 1);
}
private Template getTemplate() {

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/condition/CommandDisabledCondition.java
View File

@@ -3,7 +3,7 @@ package dev.sheldan.abstracto.core.command.condition;
import dev.sheldan.abstracto.core.command.Command;
import dev.sheldan.abstracto.core.command.condition.detail.CommandDisabledDetail;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.service.ChannelGroupCommandService;
import dev.sheldan.abstracto.core.command.service.management.CommandManagementService;
import org.springframework.beans.factory.annotation.Autowired;

4
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/condition/CommandDisallowedCondition.java
View File

@@ -3,8 +3,8 @@ package dev.sheldan.abstracto.core.command.condition;
import dev.sheldan.abstracto.core.command.Command;
import dev.sheldan.abstracto.core.command.condition.detail.InsufficientPermissionConditionDetail;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.models.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.service.management.CommandInServerManagementService;
import dev.sheldan.abstracto.core.command.service.management.CommandManagementService;
import dev.sheldan.abstracto.core.models.database.ARole;

4
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/condition/ImmuneUserCondition.java
View File

@@ -3,8 +3,8 @@ package dev.sheldan.abstracto.core.command.condition;
import dev.sheldan.abstracto.core.command.Command;
import dev.sheldan.abstracto.core.command.condition.detail.ImmuneUserConditionDetail;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.models.database.ACommand;
import dev.sheldan.abstracto.core.command.models.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.model.database.ACommand;
import dev.sheldan.abstracto.core.command.model.database.ACommandInAServer;
import dev.sheldan.abstracto.core.command.service.management.CommandInServerManagementService;
import dev.sheldan.abstracto.core.command.service.management.CommandManagementService;
import dev.sheldan.abstracto.core.models.database.ARole;

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/condition/detail/FeatureDisabledConditionDetail.java
View File

@@ -1,7 +1,7 @@
package dev.sheldan.abstracto.core.command.condition.detail;
import dev.sheldan.abstracto.core.command.condition.ConditionDetail;
import dev.sheldan.abstracto.core.command.models.condition.FeatureDisabledConditionDetailModel;
import dev.sheldan.abstracto.core.command.model.condition.FeatureDisabledConditionDetailModel;
import dev.sheldan.abstracto.core.config.FeatureConfig;
import lombok.Getter;
import lombok.Setter;

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/condition/detail/ImmuneUserConditionDetail.java
View File

@@ -1,7 +1,7 @@
package dev.sheldan.abstracto.core.command.condition.detail;
import dev.sheldan.abstracto.core.command.condition.ConditionDetail;
import dev.sheldan.abstracto.core.command.models.condition.ImmuneUserConditionDetailModel;
import dev.sheldan.abstracto.core.command.model.condition.ImmuneUserConditionDetailModel;
import net.dv8tion.jda.api.entities.Role;
public class ImmuneUserConditionDetail implements ConditionDetail {

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/condition/detail/InsufficientPermissionConditionDetail.java
View File

@@ -1,7 +1,7 @@
package dev.sheldan.abstracto.core.command.condition.detail;
import dev.sheldan.abstracto.core.command.condition.ConditionDetail;
import dev.sheldan.abstracto.core.command.models.condition.InsufficientPermissionCondtionDetailModel;
import dev.sheldan.abstracto.core.command.model.condition.InsufficientPermissionCondtionDetailModel;
import net.dv8tion.jda.api.entities.Role;
import java.util.List;

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/exception/ChannelAlreadyInChannelGroupException.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.core.command.exception;
import dev.sheldan.abstracto.core.command.models.exception.ChannelAlreadyInChannelGroupExceptionModel;
import dev.sheldan.abstracto.core.command.model.exception.ChannelAlreadyInChannelGroupExceptionModel;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AChannelGroup;

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/exception/ChannelGroupExistsException.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.core.command.exception;
import dev.sheldan.abstracto.core.command.models.exception.ChannelGroupExistsExceptionModel;
import dev.sheldan.abstracto.core.command.model.exception.ChannelGroupExistsExceptionModel;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
import dev.sheldan.abstracto.core.templating.Templatable;

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/exception/ChannelGroupIncorrectTypeException.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.core.command.exception;
import dev.sheldan.abstracto.core.command.models.exception.ChannelGroupIncorrectTypeExceptionModel;
import dev.sheldan.abstracto.core.command.model.exception.ChannelGroupIncorrectTypeExceptionModel;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
import dev.sheldan.abstracto.core.templating.Templatable;

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/exception/ChannelGroupNotFoundException.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.core.command.exception;
import dev.sheldan.abstracto.core.command.models.exception.ChannelGroupNotFoundExceptionModel;
import dev.sheldan.abstracto.core.command.model.exception.ChannelGroupNotFoundExceptionModel;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
import dev.sheldan.abstracto.core.templating.Templatable;

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/exception/ChannelNotInChannelGroupException.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.core.command.exception;
import dev.sheldan.abstracto.core.command.models.exception.ChannelNotInChannelGroupExceptionModel;
import dev.sheldan.abstracto.core.command.model.exception.ChannelNotInChannelGroupExceptionModel;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AChannelGroup;

27
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/exception/CommandAliasAlreadyExistsException.java Normal file
View File

@@ -0,0 +1,27 @@
package dev.sheldan.abstracto.core.command.exception;
import dev.sheldan.abstracto.core.command.model.exception.CommandAliasAlreadyExistsModel;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
import dev.sheldan.abstracto.core.templating.Templatable;
public class CommandAliasAlreadyExistsException extends AbstractoRunTimeException implements Templatable {
private final CommandAliasAlreadyExistsModel model;
public CommandAliasAlreadyExistsException(String existingCommand) {
this.model = CommandAliasAlreadyExistsModel
.builder()
.existingCommand(existingCommand)
.build();
}
@Override
public String getTemplateName() {
return "command_in_server_alias_already_exists_exception";
}
@Override
public Object getTemplateModel() {
return model;
}
}

19
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/exception/CommandAliasDoesNotExistsException.java Normal file
View File

@@ -0,0 +1,19 @@
package dev.sheldan.abstracto.core.command.exception;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
import dev.sheldan.abstracto.core.templating.Templatable;
import lombok.NoArgsConstructor;
@NoArgsConstructor
public class CommandAliasDoesNotExistsException extends AbstractoRunTimeException implements Templatable {
@Override
public String getTemplateName() {
return "command_in_server_alias_not_exists_exists_exception";
}
@Override
public Object getTemplateModel() {
return new Object();
}
}

27
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/exception/CommandAliasHidesCommandException.java Normal file
View File

@@ -0,0 +1,27 @@
package dev.sheldan.abstracto.core.command.exception;
import dev.sheldan.abstracto.core.command.model.exception.CommandAliasHidesCommandModel;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
import dev.sheldan.abstracto.core.templating.Templatable;
public class CommandAliasHidesCommandException extends AbstractoRunTimeException implements Templatable {
private final CommandAliasHidesCommandModel model;
public CommandAliasHidesCommandException(String existingCommand) {
this.model = CommandAliasHidesCommandModel
.builder()
.existingCommand(existingCommand)
.build();
}
@Override
public String getTemplateName() {
return "command_in_server_alias_hides_command_exception";
}
@Override
public Object getTemplateModel() {
return model;
}
}

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/exception/CommandParameterKeyValueWrongTypeException.java
View File

@@ -1,6 +1,6 @@
package dev.sheldan.abstracto.core.command.exception;
import dev.sheldan.abstracto.core.command.models.exception.CommandParameterKeyValueWrongTypeExceptionModel;
import dev.sheldan.abstracto.core.command.model.exception.CommandParameterKeyValueWrongTypeExceptionModel;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
import dev.sheldan.abstracto.core.templating.Templatable;

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/exception/CommandParameterValidationException.java
View File

@@ -2,7 +2,7 @@ package dev.sheldan.abstracto.core.command.exception;
import dev.sheldan.abstracto.core.command.config.Parameter;
import dev.sheldan.abstracto.core.command.config.validator.ValidatorParam;
import dev.sheldan.abstracto.core.command.models.exception.CommandParameterValidationExceptionModel;
import dev.sheldan.abstracto.core.command.model.exception.CommandParameterValidationExceptionModel;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
import dev.sheldan.abstracto.core.templating.Templatable;
import lombok.Getter;

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/exception/IncorrectParameterException.java
View File

@@ -1,7 +1,7 @@
package dev.sheldan.abstracto.core.command.exception;
import dev.sheldan.abstracto.core.command.Command;
import dev.sheldan.abstracto.core.command.models.exception.IncorrectParameterExceptionModel;
import dev.sheldan.abstracto.core.command.model.exception.IncorrectParameterExceptionModel;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
import dev.sheldan.abstracto.core.templating.Templatable;

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/exception/InsufficientParametersException.java
View File

@@ -1,7 +1,7 @@
package dev.sheldan.abstracto.core.command.exception;
import dev.sheldan.abstracto.core.command.Command;
import dev.sheldan.abstracto.core.command.models.exception.InsufficientParametersExceptionModel;
import dev.sheldan.abstracto.core.command.model.exception.InsufficientParametersExceptionModel;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
import dev.sheldan.abstracto.core.templating.Templatable;

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/models/TableLocks.java → abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/model/TableLocks.java
View File

@@ -1,4 +1,4 @@
package dev.sheldan.abstracto.core.command.models;
package dev.sheldan.abstracto.core.command.model;
public enum TableLocks {
CHANNELS, USER_IN_SERVER, USER

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/models/condition/FeatureDisabledConditionDetailModel.java → abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/model/condition/FeatureDisabledConditionDetailModel.java
View File

@@ -1,4 +1,4 @@
package dev.sheldan.abstracto.core.command.models.condition;
package dev.sheldan.abstracto.core.command.model.condition;
import dev.sheldan.abstracto.core.config.FeatureConfig;
import lombok.Builder;

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/models/condition/GenericConditionModel.java → abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/model/condition/GenericConditionModel.java
View File

@@ -1,4 +1,4 @@
package dev.sheldan.abstracto.core.command.models.condition;
package dev.sheldan.abstracto.core.command.model.condition;
import dev.sheldan.abstracto.core.command.condition.ConditionDetail;
import dev.sheldan.abstracto.core.models.GuildChannelMember;

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/models/condition/ImmuneUserConditionDetailModel.java → abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/model/condition/ImmuneUserConditionDetailModel.java
View File

@@ -1,4 +1,4 @@
package dev.sheldan.abstracto.core.command.models.condition;
package dev.sheldan.abstracto.core.command.model.condition;
import lombok.Builder;
import lombok.Getter;

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/models/condition/InsufficientPermissionCondtionDetailModel.java → abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/model/condition/InsufficientPermissionCondtionDetailModel.java
View File

@@ -1,4 +1,4 @@
package dev.sheldan.abstracto.core.command.models.condition;
package dev.sheldan.abstracto.core.command.model.condition;
import lombok.Builder;
import lombok.Getter;

2
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/models/database/ACommand.java → abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/model/database/ACommand.java
View File

@@ -1,4 +1,4 @@
package dev.sheldan.abstracto.core.command.models.database;
package dev.sheldan.abstracto.core.command.model.database;
import dev.sheldan.abstracto.core.models.database.AChannelGroupCommand;
import dev.sheldan.abstracto.core.models.database.AFeature;

5
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/models/database/ACommandInAServer.java → abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/model/database/ACommandInAServer.java
View File

@@ -1,4 +1,4 @@
package dev.sheldan.abstracto.core.command.models.database;
package dev.sheldan.abstracto.core.command.model.database;
import dev.sheldan.abstracto.core.models.database.ARole;
import dev.sheldan.abstracto.core.models.database.AServer;
@@ -47,6 +47,9 @@ public class ACommandInAServer implements Serializable {
@Getter
private List<ARole> immuneRoles;
@OneToMany(mappedBy = "commandInAServer", fetch = FetchType.LAZY)
private List<ACommandInServerAlias> aliases;
@Getter
@Setter
@Column(name = "restricted")

29
abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/model/database/ACommandInServerAlias.java Normal file
View File

@@ -0,0 +1,29 @@
package dev.sheldan.abstracto.core.command.model.database;
import lombok.*;
import javax.persistence.*;
import java.io.Serializable;
import java.time.Instant;
@Entity(name = "command_in_server_alias")
@Getter
@Builder
@Setter
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode
public class ACommandInServerAlias implements Serializable {
@EmbeddedId
private CommandInServerAliasId aliasId;
@ManyToOne(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
@MapsId("commandInServerId")
@JoinColumn(name = "command_in_server_id", referencedColumnName = "command_in_server_id", nullable = false)
private ACommandInAServer commandInAServer;
@Column(name = "created")
private Instant created;
}

Some files were not shown because too many files have changed in this diff Show More