Sheldan/abstracto
1
0
Fork 0
mirror of https://github.com/Sheldan/abstracto.git synced 2026-01-22 17:45:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

added command to manage channel groups

Browse Source 
added ability to disable command in channel groups
refactored embed handling to support multiple embeds to be send at once (handling to decide to split into multiple embeds is still needed)
This commit is contained in:
Sheldan
2020-04-06 00:51:07 +02:00
parent 4b3765ee0f
commit 20cb43d071
60 changed files with 840 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -2,11 +2,14 @@ package dev.sheldan.abstracto.core.command;
import dev.sheldan.abstracto.core.command.exception.IncorrectParameter;
import dev.sheldan.abstracto.core.command.exception.ParameterTooLong;
import dev.sheldan.abstracto.core.command.models.ACommand;
import dev.sheldan.abstracto.core.command.service.ChannelGroupCommandService;
import dev.sheldan.abstracto.core.command.service.PostCommandExecution;
import dev.sheldan.abstracto.core.command.execution.*;
import dev.sheldan.abstracto.core.command.meta.UnParsedCommandParameter;
import dev.sheldan.abstracto.core.Constants;
import dev.sheldan.abstracto.core.exception.*;
import dev.sheldan.abstracto.core.command.service.management.CommandManagementService;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import dev.sheldan.abstracto.core.service.management.UserManagementService;
@@ -57,6 +60,12 @@ public class CommandReceivedHandler extends ListenerAdapter {
@Lazy
private CommandReceivedHandler self;
@Autowired
private ChannelGroupCommandService channelGroupCommandService;
@Autowired
private CommandManagementService commandManagementService;
@Override
@Async
@Transactional
@@ -85,8 +94,9 @@ public class CommandReceivedHandler extends ListenerAdapter {
CommandContext commandContext = commandContextBuilder.parameters(parsedParameters).build();
if(foundCommand instanceof ConditionalCommand) {
ConditionalCommand castedCommand = (ConditionalCommand) foundCommand;
if (!shouldExecute(commandContext, foundCommand, castedCommand.getConditions())) {
throw new FeatureDisabledException(String.format("Feature `%s` has been disabled. Command is not usable", foundCommand.getFeature()));
ConditionResult conditionResult = checkConditions(commandContext, foundCommand, castedCommand.getConditions());
if(!conditionResult.isResult()) {
throw new AbstractoRunTimeException(conditionResult.getReason());
}
}
CommandResult commandResult = self.executeCommand(foundCommand, commandContext);
@@ -107,14 +117,16 @@ public class CommandReceivedHandler extends ListenerAdapter {
return foundCommand.execute(commandContext);
}
public boolean shouldExecute(CommandContext commandContext, Command command, List<CommandCondition> conditions) {
AtomicBoolean shouldExecute = new AtomicBoolean(true);
public ConditionResult checkConditions(CommandContext commandContext, Command command, List<CommandCondition> conditions) {
if(conditions != null) {
conditions.forEach(condition -> {
shouldExecute.set(shouldExecute.get() && condition.shouldExecute(commandContext, command));
});
for (CommandCondition condition : conditions) {
ConditionResult conditionResult = condition.shouldExecute(commandContext, command);
if(!conditionResult.isResult()) {
return conditionResult;
}
}
}
return shouldExecute.get();
return ConditionResult.builder().result(true).build();
}
private UserInitiatedServerContext buildTemplateParameter(MessageReceivedEvent event) {
@@ -135,7 +147,7 @@ public class CommandReceivedHandler extends ListenerAdapter {
public Parameters getParsedParameters(UnParsedCommandParameter unParsedCommandParameter, Command command, Message message){
List<Object> parsedParameters = new ArrayList<>();
if(command.getConfiguration().getParameters().size() == 0) {
if(command.getConfiguration().getParameters() == null || command.getConfiguration().getParameters().size() == 0) {
return Parameters.builder().parameters(parsedParameters).build();
}
Iterator<TextChannel> channelIterator = message.getMentionedChannels().iterator();

9
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/exception/ChannelGroupException.java Normal file
View File

@@ -0,0 +1,9 @@
package dev.sheldan.abstracto.core.command.exception;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
public class ChannelGroupException extends AbstractoRunTimeException {
public ChannelGroupException(String message) {
super(message);
}
}

9
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/exception/CommandException.java Normal file
View File

@@ -0,0 +1,9 @@
package dev.sheldan.abstracto.core.command.exception;
import dev.sheldan.abstracto.core.exception.AbstractoRunTimeException;
public class CommandException extends AbstractoRunTimeException {
public CommandException(String message) {
super(message);
}
}

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

@@ -23,6 +23,7 @@ public class ExceptionPostExecution implements PostCommandExecution {
if(commandResult.getResult().equals(ResultState.ERROR)) {
Throwable throwable = commandResult.getThrowable();
if(throwable != null) {
log.error("Exception: ", throwable);
if(throwable instanceof Templatable) {
Templatable exception = (Templatable) throwable;
String text = templateService.renderTemplate(exception.getTemplateName(), exception.getTemplateModel());

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

@@ -0,0 +1,13 @@
package dev.sheldan.abstracto.core.command.repository;
import dev.sheldan.abstracto.core.command.models.ACommand;
import dev.sheldan.abstracto.core.models.database.AChannelGroup;
import dev.sheldan.abstracto.core.models.database.AChannelGroupCommand;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
public interface ChannelGroupCommandRepository extends JpaRepository<AChannelGroupCommand, Long> {
AChannelGroupCommand findByCommandAndGroup(ACommand command, AChannelGroup group);
List<AChannelGroupCommand> findByCommand(ACommand command);
}

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

@@ -0,0 +1,36 @@
package dev.sheldan.abstracto.core.command.service;
import dev.sheldan.abstracto.core.command.models.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;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Optional;
@Component
public class ChannelGroupCommandServiceBean implements ChannelGroupCommandService {
@Autowired
private ChannelGroupCommandManagementService channelGroupCommandService;
@Override
public Boolean isCommandEnabled(ACommand command, AChannel channel) {
List<AChannelGroupCommand> allChannelGroupsOfCommand = channelGroupCommandService.getAllGroupCommandsForCommand(command);
for (AChannelGroupCommand aChannelGroupCommand : allChannelGroupsOfCommand) {
Optional<AChannel> channelInGroup = aChannelGroupCommand.getGroup()
.getChannels().stream().filter(channel1 -> channel1.getId().equals(channel.getId())).findAny();
if (channelInGroup.isPresent()) {
if (aChannelGroupCommand.getEnabled()) {
return true;
}
}
}
if(allChannelGroupsOfCommand.size() == 0) {
return true;
}
return false;
}
}

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

@@ -2,7 +2,6 @@ package dev.sheldan.abstracto.core.command.service;
import dev.sheldan.abstracto.core.command.models.ACommand;
import dev.sheldan.abstracto.core.command.models.AModule;
import dev.sheldan.abstracto.core.command.service.CommandService;
import dev.sheldan.abstracto.core.command.service.management.CommandManagementService;
import dev.sheldan.abstracto.core.command.service.management.ModuleManagementService;
import org.springframework.beans.factory.annotation.Autowired;

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

@@ -0,0 +1,52 @@
package dev.sheldan.abstracto.core.command.service.management;
import dev.sheldan.abstracto.core.command.models.ACommand;
import dev.sheldan.abstracto.core.command.repository.ChannelGroupCommandRepository;
import dev.sheldan.abstracto.core.models.database.AChannelGroup;
import dev.sheldan.abstracto.core.models.database.AChannelGroupCommand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;
@Component
public class ChannelGroupCommandManagementServiceBean implements ChannelGroupCommandManagementService {
@Autowired
private ChannelGroupCommandRepository groupCommandRepository;
@Override
public void setCommandInGroupTo(ACommand command, AChannelGroup group, Boolean enabled) {
AChannelGroupCommand groupCommand = groupCommandRepository.findByCommandAndGroup(command, group);
if(groupCommand == null) {
groupCommand = createCommandInGroupTo(command, group);
}
groupCommand.setEnabled(enabled);
groupCommandRepository.save(groupCommand);
}
@Override
public AChannelGroupCommand createCommandInGroupTo(ACommand command, AChannelGroup group) {
AChannelGroupCommand channelGroupCommand = AChannelGroupCommand
.builder()
.command(command)
.group(group)
.enabled(false)
.build();
groupCommandRepository.save(channelGroupCommand);
return channelGroupCommand;
}
@Override
public AChannelGroupCommand getChannelGroupCommand(ACommand command, AChannelGroup group) {
return groupCommandRepository.findByCommandAndGroup(command, group);
}
@Override
public List<AChannelGroupCommand> getAllGroupCommandsForCommand(ACommand command) {
return groupCommandRepository.findByCommand(command);
}
}

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/channels/AddToChannelGroup.java
View File

@@ -37,7 +37,7 @@ public class AddToChannelGroup implements Command {
List<String> aliases = Arrays.asList("addTChGrp", "chGrpCh+");
return CommandConfiguration.builder()
.name("addToChannelGroup")
.module("channels")
.module(ChannelsModuleInterface.CHANNELS)
.aliases(aliases)
.parameters(parameters)
.description("Adds the mentioned channel to the channel group.")

5
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/channels/ChannelsModuleInterface.java
View File

@@ -6,9 +6,12 @@ import org.springframework.stereotype.Component;
@Component
public class ChannelsModuleInterface implements ModuleInterface {
public static final String CHANNELS = "channels";
@Override
public ModuleInfo getInfo() {
return ModuleInfo.builder().name("channels").description("Includes utilities to configure the channel configuration stored in the database").build();
return ModuleInfo.builder().name(CHANNELS).description("Includes utilities to configure the channel configuration stored in the database").build();
}
@Override

6
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/channels/CreateChannelGroup.java
View File

@@ -22,7 +22,7 @@ public class CreateChannelGroup implements Command {
@Override
public CommandResult execute(CommandContext commandContext) {
String groupName = (String) commandContext.getParameters().getParameters().get(0);
channelGroupService.createChannelGroup(groupName);
channelGroupService.createChannelGroup(groupName, commandContext.getGuild().getIdLong());
return CommandResult.fromSuccess();
}
@@ -30,10 +30,12 @@ public class CreateChannelGroup implements Command {
public CommandConfiguration getConfiguration() {
Parameter channelGroupName = Parameter.builder().name("name").type(String.class).description("The name of the channel group to create.").build();
List<Parameter> parameters = Arrays.asList(channelGroupName);
List<String> aliases = Arrays.asList("+ChGroup");
return CommandConfiguration.builder()
.name("createChannelGroup")
.module("channels")
.module(ChannelsModuleInterface.CHANNELS)
.parameters(parameters)
.aliases(aliases)
.description("Creates a channel group to which channels can be added to.")
.causesReaction(true)
.build();

48
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/channels/DeleteChannelGroup.java Normal file
View File

@@ -0,0 +1,48 @@
package dev.sheldan.abstracto.core.commands.channels;
import dev.sheldan.abstracto.core.command.Command;
import dev.sheldan.abstracto.core.command.execution.CommandConfiguration;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.execution.Parameter;
import dev.sheldan.abstracto.core.config.AbstractoFeatures;
import dev.sheldan.abstracto.core.service.ChannelGroupService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
@Component
public class DeleteChannelGroup implements Command {
@Autowired
private ChannelGroupService channelGroupService;
@Override
public CommandResult execute(CommandContext commandContext) {
String groupName = (String) commandContext.getParameters().getParameters().get(0);
channelGroupService.deleteChannelGroup(groupName, commandContext.getGuild().getIdLong());
return CommandResult.fromSuccess();
}
@Override
public CommandConfiguration getConfiguration() {
Parameter channelGroupName = Parameter.builder().name("name").type(String.class).description("The name of the channel group to delete.").build();
List<Parameter> parameters = Arrays.asList(channelGroupName);
List<String> aliases = Arrays.asList("-ChGroup");
return CommandConfiguration.builder()
.name("deleteChannelGroup")
.module(ChannelsModuleInterface.CHANNELS)
.parameters(parameters)
.aliases(aliases)
.description("Removes an existing channel group.")
.causesReaction(true)
.build();
}
@Override
public String getFeature() {
return AbstractoFeatures.CORE;
}
}

48
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/channels/DisableCommand.java Normal file
View File

@@ -0,0 +1,48 @@
package dev.sheldan.abstracto.core.commands.channels;
import dev.sheldan.abstracto.core.command.Command;
import dev.sheldan.abstracto.core.command.execution.CommandConfiguration;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.execution.Parameter;
import dev.sheldan.abstracto.core.config.AbstractoFeatures;
import dev.sheldan.abstracto.core.service.ChannelGroupService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
@Component
public class DisableCommand implements Command {
@Autowired
private ChannelGroupService channelGroupService;
@Override
public CommandResult execute(CommandContext commandContext) {
String commandName = (String) commandContext.getParameters().getParameters().get(0);
String channelGroupName = (String) commandContext.getParameters().getParameters().get(1);
channelGroupService.disableCommandInChannelGroup(commandName, channelGroupName, commandContext.getGuild().getIdLong());
return CommandResult.fromSuccess();
}
@Override
public CommandConfiguration getConfiguration() {
Parameter channelGroupName = Parameter.builder().name("commandName").type(String.class).description("The name of the channel group to add the channel to.").build();
Parameter channelToAdd = Parameter.builder().name("channelGroup").type(String.class).description("The name of the channel group in which the command should be disabled.").build();
List<Parameter> parameters = Arrays.asList(channelGroupName, channelToAdd);
return CommandConfiguration.builder()
.name("disableCommand")
.module(ChannelsModuleInterface.CHANNELS)
.parameters(parameters)
.description("Disables the given command in the given channel group.")
.causesReaction(true)
.build();
}
@Override
public String getFeature() {
return AbstractoFeatures.CORE;
}
}

48
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/channels/EnableCommand.java Normal file
View File

@@ -0,0 +1,48 @@
package dev.sheldan.abstracto.core.commands.channels;
import dev.sheldan.abstracto.core.command.Command;
import dev.sheldan.abstracto.core.command.execution.CommandConfiguration;
import dev.sheldan.abstracto.core.command.execution.CommandContext;
import dev.sheldan.abstracto.core.command.execution.CommandResult;
import dev.sheldan.abstracto.core.command.execution.Parameter;
import dev.sheldan.abstracto.core.config.AbstractoFeatures;
import dev.sheldan.abstracto.core.service.ChannelGroupService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
@Component
public class EnableCommand implements Command {
@Autowired
private ChannelGroupService channelGroupService;
@Override
public CommandResult execute(CommandContext commandContext) {
String commandName = (String) commandContext.getParameters().getParameters().get(0);
String channelGroupName = (String) commandContext.getParameters().getParameters().get(1);
channelGroupService.enableCommandInChannelGroup(commandName, channelGroupName, commandContext.getGuild().getIdLong());
return CommandResult.fromSuccess();
}
@Override
public CommandConfiguration getConfiguration() {
Parameter channelGroupName = Parameter.builder().name("commandName").type(String.class).description("The name of the channel group to add the channel to.").build();
Parameter channelToAdd = Parameter.builder().name("channelGroup").type(String.class).description("The name of the channel group in which the command should be disabled.").build();
List<Parameter> parameters = Arrays.asList(channelGroupName, channelToAdd);
return CommandConfiguration.builder()
.name("enableCommand")
.module(ChannelsModuleInterface.CHANNELS)
.parameters(parameters)
.description("Disables the given command in the given channel group.")
.causesReaction(true)
.build();
}
@Override
public String getFeature() {
return AbstractoFeatures.CORE;
}
}

89
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/channels/ListChannelGroups.java Normal file
View File

@@ -0,0 +1,89 @@
package dev.sheldan.abstracto.core.commands.channels;
import dev.sheldan.abstracto.core.command.Command;
import dev.sheldan.abstracto.core.command.execution.CommandConfiguration;
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.config.AbstractoFeatures;
import dev.sheldan.abstracto.core.models.MessageToSend;
import dev.sheldan.abstracto.core.models.command.ChannelGroupChannelModel;
import dev.sheldan.abstracto.core.models.command.ChannelGroupModel;
import dev.sheldan.abstracto.core.models.command.ListChannelGroupsModel;
import dev.sheldan.abstracto.core.models.database.AChannelGroup;
import dev.sheldan.abstracto.core.service.ChannelService;
import dev.sheldan.abstracto.core.service.management.ChannelGroupManagementService;
import dev.sheldan.abstracto.templating.TemplateService;
import net.dv8tion.jda.api.entities.TextChannel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
@Component
public class ListChannelGroups implements Command {
@Autowired
private TemplateService templateService;
@Autowired
private ChannelGroupManagementService channelGroupManagementService;
@Autowired
private ChannelService channelService;
@Override
public CommandResult execute(CommandContext commandContext) {
List<AChannelGroup> channelGroups = channelGroupManagementService.findAllInServer(commandContext.getUserInitiatedContext().getServer());
ListChannelGroupsModel template = (ListChannelGroupsModel) ContextConverter.fromCommandContext(commandContext, ListChannelGroupsModel.class);
template.setGroups(convertAChannelGroupToChannelGroupChannel(channelGroups));
MessageToSend response = templateService.renderEmbedTemplate("listChannelGroups_response", template);
channelService.sendMessageToEndInTextChannel(response, commandContext.getChannel());
return CommandResult.fromSuccess();
}
private List<ChannelGroupModel> convertAChannelGroupToChannelGroupChannel(List<AChannelGroup> channelGroups) {
List<ChannelGroupModel> converted = new ArrayList<>();
channelGroups.forEach(group -> {
List<ChannelGroupChannelModel> convertedChannels = new ArrayList<>();
group.getChannels().forEach(channel -> {
Optional<TextChannel> textChannelInGuild = channelService.getTextChannelInGuild(channel.getServer().getId(), channel.getId());
if(textChannelInGuild.isPresent()) {
ChannelGroupChannelModel convertedChannel = ChannelGroupChannelModel
.builder()
.channel(channel)
.discordChannel(textChannelInGuild.get())
.build();
convertedChannels.add(convertedChannel);
}
});
ChannelGroupModel channelGroup = ChannelGroupModel
.builder()
.name(group.getGroupName())
.channels(convertedChannels)
.build();
converted.add(channelGroup);
});
return converted;
}
@Override
public CommandConfiguration getConfiguration() {
List<String> aliases = Arrays.asList("lsChGrp");
return CommandConfiguration.builder()
.name("listChannelGroups")
.module(ChannelsModuleInterface.CHANNELS)
.aliases(aliases)
.description("Lists the current channel groups and their respective groups.")
.causesReaction(true)
.build();
}
@Override
public String getFeature() {
return AbstractoFeatures.CORE;
}
}

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/channels/PostTarget.java
View File

@@ -65,7 +65,7 @@ public class PostTarget implements Command {
List<Parameter> parameters = Arrays.asList(postTargetName, channel);
return CommandConfiguration.builder()
.name("posttarget")
.module("channels")
.module(ChannelsModuleInterface.CHANNELS)
.parameters(parameters)
.description("Sets the target of a post done by the bot")
.causesReaction(true)

2
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/commands/channels/RemoveFromChannelGroup.java
View File

@@ -37,7 +37,7 @@ public class RemoveFromChannelGroup implements Command {
List<String> aliases = Arrays.asList("rmChChgrp", "chGrpCh-");
return CommandConfiguration.builder()
.name("removeFromChannelGroup")
.module("channels")
.module(ChannelsModuleInterface.CHANNELS)
.aliases(aliases)
.parameters(parameters)
.description("Removes the mentioned channel from the channel group.")

6
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/repository/ChannelGroupRepository.java
View File

@@ -1,8 +1,12 @@
package dev.sheldan.abstracto.core.repository;
import dev.sheldan.abstracto.core.models.database.AChannelGroup;
import dev.sheldan.abstracto.core.models.database.AServer;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
public interface ChannelGroupRepository extends JpaRepository<AChannelGroup, Long> {
AChannelGroup findByGroupName(String name);
AChannelGroup findByGroupNameAndServer(String name, AServer server);
List<AChannelGroup> findByServer(AServer server);
}

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

@@ -1,9 +1,16 @@
package dev.sheldan.abstracto.core.service;
import dev.sheldan.abstracto.core.command.exception.ChannelGroupException;
import dev.sheldan.abstracto.core.command.exception.CommandException;
import dev.sheldan.abstracto.core.command.models.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;
import dev.sheldan.abstracto.core.models.database.AChannelGroup;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.service.management.ChannelGroupManagementService;
import dev.sheldan.abstracto.core.service.management.ChannelManagementService;
import dev.sheldan.abstracto.core.service.management.ServerManagementService;
import net.dv8tion.jda.api.entities.TextChannel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@@ -17,9 +24,25 @@ public class ChannelGroupServiceBean implements ChannelGroupService {
@Autowired
private ChannelManagementService channelManagementService;
@Autowired
private CommandManagementService commandManagementService;
@Autowired
private ChannelGroupCommandManagementService channelGroupCommandManagementService;
@Autowired
private ServerManagementService serverManagementService;
@Override
public AChannelGroup createChannelGroup(String name) {
return channelGroupManagementService.createChannelGroup(name);
public AChannelGroup createChannelGroup(String name, Long serverId) {
AServer server = serverManagementService.loadOrCreate(serverId);
return channelGroupManagementService.createChannelGroup(name, server);
}
@Override
public void deleteChannelGroup(String name, Long serverId) {
AServer server = serverManagementService.loadOrCreate(serverId);
channelGroupManagementService.deleteChannelGroup(name, server);
}
@Override
@@ -35,7 +58,11 @@ public class ChannelGroupServiceBean implements ChannelGroupService {
@Override
public void addChannelToChannelGroup(String channelGroupName, AChannel channel) {
AChannelGroup channelGroup = channelGroupManagementService.findByName(channelGroupName);
AServer server = serverManagementService.loadOrCreate(channel.getServer().getId());
AChannelGroup channelGroup = channelGroupManagementService.findByNameAndServer(channelGroupName, server);
if(channelGroup == null) {
throw new ChannelGroupException(String.format("Channel group %s was not found.", channelGroupName));
}
channelGroupManagementService.addChannelToChannelGroup(channelGroup, channel);
}
@@ -52,7 +79,45 @@ public class ChannelGroupServiceBean implements ChannelGroupService {
@Override
public void removeChannelFromChannelGroup(String channelGroupName, AChannel channel) {
AChannelGroup channelGroup = channelGroupManagementService.findByName(channelGroupName);
AServer server = serverManagementService.loadOrCreate(channel.getServer().getId());
AChannelGroup channelGroup = channelGroupManagementService.findByNameAndServer(channelGroupName, server);
if(channelGroup == null) {
throw new ChannelGroupException(String.format("Channel group %s was not found", channelGroupName));
}
channelGroupManagementService.removeChannelFromChannelGroup(channelGroup, channel);
}
@Override
public void disableCommandInChannelGroup(String commandName, String channelGroupName, Long serverId) {
AServer server = serverManagementService.loadOrCreate(serverId);
AChannelGroup channelGroup = channelGroupManagementService.findByNameAndServer(channelGroupName, server);
if(channelGroup == null) {
throw new ChannelGroupException(String.format("Channel group %s was not found", channelGroupName));
}
ACommand command = commandManagementService.findCommandByName(commandName);
if(command == null) {
throw new CommandException(String.format("Command %s not found.", commandName));
}
channelGroupCommandManagementService.setCommandInGroupTo(command, channelGroup, false);
}
@Override
public void enableCommandInChannelGroup(String commandName, String channelGroupName, Long serverId) {
AServer server = serverManagementService.loadOrCreate(serverId);
AChannelGroup channelGroup = channelGroupManagementService.findByNameAndServer(channelGroupName, server);
if(channelGroup == null) {
throw new ChannelGroupException(String.format("Channel group %s was not found", channelGroupName));
}
ACommand command = commandManagementService.findCommandByName(commandName);
if(command == null) {
throw new CommandException(String.format("Command %s not found.", commandName));
}
channelGroupCommandManagementService.setCommandInGroupTo(command, channelGroup, true);
}
@Override
public boolean doesGroupExist(String groupName, Long serverId) {
AServer server = serverManagementService.loadOrCreate(serverId);
return channelGroupManagementService.findByNameAndServer(groupName, server) != null;
}
}

48
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/ChannelServiceBean.java
View File

@@ -2,13 +2,22 @@ package dev.sheldan.abstracto.core.service;
import dev.sheldan.abstracto.core.exception.ChannelException;
import dev.sheldan.abstracto.core.exception.GuildException;
import dev.sheldan.abstracto.core.models.MessageToSend;
import dev.sheldan.abstracto.core.models.database.AChannel;
import lombok.extern.slf4j.Slf4j;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.TextChannel;
import net.dv8tion.jda.api.requests.restaction.MessageAction;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
@Slf4j
@Component
public class ChannelServiceBean implements ChannelService {
@@ -32,4 +41,43 @@ public class ChannelServiceBean implements ChannelService {
throw new GuildException(String.format("Guild %s to post in channel %s was not found.", channel.getServer().getId(), channel.getId()));
}
}
@Override
public List<CompletableFuture<Message>> sendMessageToEndInAChannel(MessageToSend messageToSend, AChannel channel) {
Optional<TextChannel> textChannelFromServer = botService.getTextChannelFromServer(channel.getServer().getId(), channel.getId());
if(textChannelFromServer.isPresent()) {
return sendMessageToEndInTextChannel(messageToSend, textChannelFromServer.get());
}
throw new ChannelException(String.format("Channel %s was not found.", channel.getId()));
}
@Override
public List<CompletableFuture<Message>> sendMessageToEndInTextChannel(MessageToSend messageToSend, TextChannel textChannel) {
String messageText = messageToSend.getMessage();
List<CompletableFuture<Message>> futures = new ArrayList<>();
if(StringUtils.isBlank(messageText)) {
messageToSend.getEmbeds().forEach(embed -> {
CompletableFuture<Message> messageFuture = textChannel.sendMessage(embed).submit();
futures.add(messageFuture);
});
} else {
MessageAction messageAction = textChannel.sendMessage(messageText);
if(messageToSend.getEmbeds().size() > 0) {
CompletableFuture<Message> messageFuture = messageAction.embed(messageToSend.getEmbeds().get(0)).submit();
futures.add(messageFuture);
messageToSend.getEmbeds().stream().skip(1).forEach(embed -> {
CompletableFuture<Message> nextEmbedFuture = textChannel.sendMessage(embed).submit();
futures.add(nextEmbedFuture);
});
} else {
futures.add(messageAction.submit());
}
}
return futures;
}
@Override
public Optional<TextChannel> getTextChannelInGuild(Long serverId, Long channelId) {
return botService.getTextChannelFromServer(serverId, channelId);
}
}

43
abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/service/PostTargetServiceBean.java
View File

@@ -16,6 +16,7 @@ import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CompletableFuture;
@@ -36,6 +37,9 @@ public class PostTargetServiceBean implements PostTargetService {
@Autowired
private DynamicKeyLoader dynamicKeyLoader;
@Autowired
private ChannelService channelService;
@Override
public CompletableFuture<Message> sendTextInPostTarget(String text, PostTarget target) {
TextChannel textChannelForPostTarget = getTextChannelForPostTarget(target);
@@ -88,46 +92,41 @@ public class PostTargetServiceBean implements PostTargetService {
}
@Override
public CompletableFuture<Message> sendEmbedInPostTarget(MessageToSend message, String postTargetName, Long serverId) {
public List<CompletableFuture<Message>> sendEmbedInPostTarget(MessageToSend message, String postTargetName, Long serverId) {
PostTarget postTarget = this.getPostTarget(postTargetName, serverId);
return this.sendEmbedInPostTarget(message, postTarget);
}
@Override
public CompletableFuture<Message> sendEmbedInPostTarget(MessageToSend message, PostTarget target) {
public List<CompletableFuture<Message>> sendEmbedInPostTarget(MessageToSend message, PostTarget target) {
TextChannel textChannelForPostTarget = getTextChannelForPostTarget(target);
String messageText = message.getMessage();
if(StringUtils.isBlank(messageText)) {
return textChannelForPostTarget.sendMessage(message.getEmbed()).submit();
} else {
return textChannelForPostTarget.sendMessage(messageText).embed(message.getEmbed()).submit();
}
return channelService.sendMessageToEndInTextChannel(message, textChannelForPostTarget);
}
@Override
public CompletableFuture<Message> editEmbedInPostTarget(Long messageId, MessageToSend message, PostTarget target) {
public List<CompletableFuture<Message>> editEmbedInPostTarget(Long messageId, MessageToSend message, PostTarget target) {
TextChannel textChannelForPostTarget = getTextChannelForPostTarget(target);
String messageText = message.getMessage();
if(StringUtils.isBlank(messageText)) {
return textChannelForPostTarget.editMessageById(messageId, message.getEmbed()).submit();
return Arrays.asList(textChannelForPostTarget.editMessageById(messageId, message.getEmbeds().get(0)).submit());
} else {
return textChannelForPostTarget.editMessageById(messageId, messageText).embed(message.getEmbed()).submit();
return Arrays.asList(textChannelForPostTarget.editMessageById(messageId, messageText).embed(message.getEmbeds().get(0)).submit());
}
}
@Override
public void editOrCreatedInPostTarget(Long messageId, MessageToSend messageToSend, PostTarget target, CompletableFuture<Message> future) {
public void editOrCreatedInPostTarget(Long messageId, MessageToSend messageToSend, PostTarget target, List<CompletableFuture<Message>> future) {
TextChannel textChannelForPostTarget = getTextChannelForPostTarget(target);
if(StringUtils.isBlank(messageToSend.getMessage().trim())) {
textChannelForPostTarget
.retrieveMessageById(messageId)
.queue(
existingMessage -> existingMessage
.editMessage(messageToSend.getEmbed())
.submit().thenAccept(future::complete),
.editMessage(messageToSend.getEmbeds().get(0))
.submit().thenAccept(message -> future.get(0).complete(message)),
throwable -> {
sendEmbedInPostTarget(messageToSend, target)
.thenAccept(future::complete);
sendEmbedInPostTarget(messageToSend, target).get(0)
.thenAccept(message -> future.get(0).complete(message));
});
} else {
textChannelForPostTarget
@@ -135,17 +134,17 @@ public class PostTargetServiceBean implements PostTargetService {
.queue(
existingMessage -> existingMessage
.editMessage(messageToSend.getMessage())
.embed(messageToSend.getEmbed())
.submit().thenAccept(future::complete),
.embed(messageToSend.getEmbeds().get(0))
.submit().thenAccept(message -> future.get(0).complete(message)),
throwable -> {
sendEmbedInPostTarget(messageToSend, target)
.thenAccept(future::complete);
sendEmbedInPostTarget(messageToSend, target).get(0)
.thenAccept(message -> future.get(0).complete(message));
});
}
}
@Override
public void editOrCreatedInPostTarget(Long messageId, MessageToSend messageToSend, String postTargetName, Long serverId, CompletableFuture<Message> future) {
public void editOrCreatedInPostTarget(Long messageId, MessageToSend messageToSend, String postTargetName, Long serverId, List<CompletableFuture<Message>> future) {
PostTarget postTarget = this.getPostTarget(postTargetName, serverId);
this.editOrCreatedInPostTarget(messageId, messageToSend, postTarget, future);
}
@@ -159,7 +158,7 @@ public class PostTargetServiceBean implements PostTargetService {
}
@Override
public CompletableFuture<Message> editEmbedInPostTarget(Long messageId, MessageToSend message, String postTargetName, Long serverId) {
public List<CompletableFuture<Message>> editEmbedInPostTarget(Long messageId, MessageToSend message, String postTargetName, Long serverId) {
PostTarget postTarget = this.getPostTarget(postTargetName, serverId);
return editEmbedInPostTarget(messageId, message, postTarget);
}

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

@@ -1,12 +1,15 @@
package dev.sheldan.abstracto.core.service.management;
import dev.sheldan.abstracto.core.command.exception.ChannelGroupException;
import dev.sheldan.abstracto.core.exception.ChannelException;
import dev.sheldan.abstracto.core.models.database.AChannel;
import dev.sheldan.abstracto.core.models.database.AChannelGroup;
import dev.sheldan.abstracto.core.models.database.AServer;
import dev.sheldan.abstracto.core.repository.ChannelGroupRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.function.Predicate;
@Component
@@ -15,19 +18,37 @@ public class ChannelGroupManagementServiceBean implements ChannelGroupManagement
@Autowired
private ChannelGroupRepository channelGroupRepository;
@Autowired
private ServerManagementService serverManagementService;
@Override
public AChannelGroup createChannelGroup(String name) {
public AChannelGroup createChannelGroup(String name, AServer server) {
name = name.toLowerCase();
AChannelGroup channelGroup = AChannelGroup
.builder()
.groupName(name)
.server(server)
.build();
channelGroupRepository.save(channelGroup);
return channelGroup;
}
@Override
public void deleteChannelGroup(String name, AServer server) {
name = name.toLowerCase();
AChannelGroup existing = findByNameAndServer(name, server);
if(existing == null) {
throw new ChannelGroupException(String.format("Channel group %s does not exist", name));
}
channelGroupRepository.delete(existing);
}
@Override
public AChannelGroup addChannelToChannelGroup(AChannelGroup channelGroup, AChannel channel) {
Predicate<AChannel> channelInGroupPredicate = channel1 -> channel1.getId().equals(channel.getId());
if(channelGroup == null) {
throw new ChannelGroupException("Channel group was not found.");
}
if(channelGroup.getChannels().stream().anyMatch(channelInGroupPredicate)) {
throw new ChannelException(String.format("Channel %s is already part of group %s.", channel.getId(), channelGroup.getGroupName()));
}
@@ -49,7 +70,19 @@ public class ChannelGroupManagementServiceBean implements ChannelGroupManagement
}
@Override
public AChannelGroup findByName(String name) {
return channelGroupRepository.findByGroupName(name);
public AChannelGroup findByNameAndServer(String name, AServer server) {
name = name.toLowerCase();
return channelGroupRepository.findByGroupNameAndServer(name, server);
}
@Override
public List<AChannelGroup> findAllInServer(AServer server) {
return channelGroupRepository.findByServer(server);
}
@Override
public List<AChannelGroup> findAllInServer(Long serverId) {
AServer server = serverManagementService.loadOrCreate(serverId);
return findAllInServer(server);
}
}

1
abstracto-application/core/core-impl/src/main/resources/commands.properties Normal file
View File

@@ -0,0 +1 @@
abstracto.emoteNames.postReaction=warnReaction,successReaction

23
abstracto-application/core/core-impl/src/main/resources/seedData/templates/coreCommands/listChannelGroups/listChannelGroups_response_embed_en_US.ftl Normal file
View File

@@ -0,0 +1,23 @@
{
"title": {
"title": "Current configured channel groups"
},
"color" : {
"r": 200,
"g": 0,
"b": 255
},
"fields": [
<#list groups as group>
{
"name": "${group.name}",
"value": "
<#list group.channels as channel>
${channel.discordChannel.asMention}
<#sep>,
</#list>
"
}<#sep>,
</#list>
]
}