[AB-240] changing invite filter to actively filter the server instead of only being based on the code

moving invite filter to separate module
updating to newer liquibase version
changing concept of immune roles which are directly associated to commands to immune roles which are immune against certain effects. these effects can be configured directly by the command (and a condition checks this effect), but they can be used in services as well, unrelated to commands
adding checks to not execute message received listeners for the wrong message types
adding metric support for 502 status
fixing duplicating help entries when two module definitions with the same key are present

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/condition/ConditionResult.java

@@ -11,4 +11,12 @@ public class ConditionResult {
     private boolean result;
     private String reason;
     private ConditionDetail conditionDetail;
+
+    public static ConditionResult fromSuccess() {
+        return ConditionResult.builder().result(true).build();
+    }
+
+    public static ConditionResult fromFailure(ConditionDetail detail) {
+        return ConditionResult.builder().result(false).conditionDetail(detail).build();
+    }
 }

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

@@ -2,18 +2,20 @@ 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.config.CommandConfiguration;
+import dev.sheldan.abstracto.core.command.config.EffectConfig;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
-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;
+import dev.sheldan.abstracto.core.models.database.RoleImmunity;
+import dev.sheldan.abstracto.core.service.RoleImmunityService;
 import dev.sheldan.abstracto.core.service.RoleService;
 import lombok.extern.slf4j.Slf4j;
 import net.dv8tion.jda.api.entities.Member;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
+import java.util.List;
 import java.util.Optional;
 
 @Component
@@ -29,25 +31,35 @@ public class ImmuneUserCondition implements CommandCondition {
     @Autowired
     private RoleService roleService;
 
+    @Autowired
+    private RoleImmunityService roleImmunityService;
+
     @Override
     public ConditionResult shouldExecute(CommandContext context, Command command) {
-        ACommand aCommand = commandService.findCommandByName(command.getConfiguration().getName());
-        ACommandInAServer commandForServer = commandInServerManagementService.getCommandForServer(aCommand, context.getUserInitiatedContext().getGuild().getIdLong());
-        Optional<Member> any = context.getParameters().getParameters().stream().filter(o -> o instanceof Member).map(this::toMember).findAny();
-        if(any.isPresent()) {
-            Member member = any.get();
-            for (ARole role : commandForServer.getImmuneRoles()) {
-                if (roleService.memberHasRole(member, role)) {
-                    log.debug("Member {} is immune against command {}, because of role {}.", member.getIdLong(), aCommand.getName(), role.getId());
-                    ImmuneUserConditionDetail exception = new ImmuneUserConditionDetail(roleService.getRoleFromGuild(role));
-                    return ConditionResult.builder().result(false).conditionDetail(exception).build();
+        CommandConfiguration commandConfig = command.getConfiguration();
+        if(commandConfig.getEffects().isEmpty()) {
+            return ConditionResult.fromSuccess();
+        }
+        List<Object> parameters = context.getParameters().getParameters();
+        for (EffectConfig effectConfig : commandConfig.getEffects()) {
+            Integer position = effectConfig.getPosition();
+            if (position < parameters.size()) {
+                Object parameter = parameters.get(position);
+                if (parameter instanceof Member) {
+                    Member member = (Member) parameter;
+                    Optional<RoleImmunity> immunityOptional = roleImmunityService.getRoleImmunity(member, effectConfig.getEffectKey());
+                    if (immunityOptional.isPresent()) {
+                        RoleImmunity immunity = immunityOptional.get();
+                        ImmuneUserConditionDetail conditionDetail = new ImmuneUserConditionDetail(roleService.getRoleFromGuild(immunity.getRole()),
+                                effectConfig.getEffectKey());
+                        return ConditionResult.fromFailure(conditionDetail);
+                    }
                 }
+            } else {
+                log.info("Not enough parameters ({}) in command {} to retrieve position {} to check for immunity.",
+                        parameters.size(), commandConfig.getName(), position);
             }
         }
-        return ConditionResult.builder().result(true).build();
-    }
-
-    private Member toMember(Object o) {
-        return (Member) o;
+        return ConditionResult.fromSuccess();
     }
 }

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

@@ -8,8 +8,12 @@ public class ImmuneUserConditionDetail implements ConditionDetail {
 
     private final ImmuneUserConditionDetailModel model;
 
-    public ImmuneUserConditionDetail(Role role) {
-        this.model = ImmuneUserConditionDetailModel.builder().role(role).build();
+    public ImmuneUserConditionDetail(Role role, String effectTypeKey) {
+        this.model = ImmuneUserConditionDetailModel
+                .builder()
+                .role(role)
+                .effectTypeKey(effectTypeKey)
+                .build();
     }
 
     @Override

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/config/CommandConfiguration.java

@@ -31,6 +31,8 @@ public class CommandConfiguration {
     @Builder.Default
     private boolean templated = false;
     private HelpInfo help;
+    @Builder.Default
+    private List<EffectConfig> effects = new ArrayList<>();
 
     private CommandCoolDownConfig coolDownConfig;
 

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/config/EffectConfig.java

@@ -0,0 +1,13 @@
+package dev.sheldan.abstracto.core.command.config;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@Builder
+public class EffectConfig {
+    private Integer position;
+    private String effectKey;
+}

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/model/condition/ImmuneUserConditionDetailModel.java

@@ -10,4 +10,5 @@ import net.dv8tion.jda.api.entities.Role;
 @Builder
 public class ImmuneUserConditionDetailModel {
     private Role role;
+    private String effectTypeKey;
 }

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/model/database/ACommandInAServer.java

@@ -39,14 +39,6 @@ public class ACommandInAServer implements Serializable {
     @Getter
     private List<ARole> allowedRoles;
 
-    @ManyToMany
-    @JoinTable(
-            name = "command_in_server_immune_role",
-            joinColumns = @JoinColumn(name = "command_in_server_id", referencedColumnName = "command_in_server_id"),
-            inverseJoinColumns = @JoinColumn(name = "role_id", referencedColumnName = "id"))
-    @Getter
-    private List<ARole> immuneRoles;
-
     @OneToMany(mappedBy = "commandInAServer", fetch = FetchType.LAZY)
     private List<ACommandInServerAlias> aliases;
 

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/service/CommandService.java

@@ -19,8 +19,6 @@ public interface CommandService {
     boolean doesCommandExist(String name);
     void allowCommandForRole(ACommand aCommand, ARole role);
     void allowFeatureForRole(FeatureDefinition featureDefinition, ARole role);
-    void makeRoleImmuneForCommand(ACommand aCommand, ARole role);
-    void makeRoleAffectedByCommand(ACommand aCommand, ARole role);
     void restrictCommand(ACommand aCommand, AServer server);
     String generateUsage(Command command);
     void unRestrictCommand(ACommand aCommand, AServer server);

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/exception/EffectTypeNotFoundException.java

@@ -0,0 +1,20 @@
+package dev.sheldan.abstracto.core.exception;
+
+import dev.sheldan.abstracto.core.templating.Templatable;
+
+public class EffectTypeNotFoundException extends AbstractoRunTimeException implements Templatable {
+
+    public EffectTypeNotFoundException() {
+        super("Effect type not found.");
+    }
+
+    @Override
+    public String getTemplateName() {
+        return "effect_type_not_found_exception";
+    }
+
+    @Override
+    public Object getTemplateModel() {
+        return new Object();
+    }
+}

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/models/RoleImmunityId.java

@@ -0,0 +1,52 @@
+package dev.sheldan.abstracto.core.models;
+
+import javax.persistence.Column;
+import javax.persistence.Embeddable;
+import java.io.Serializable;
+import java.util.Objects;
+
+@Embeddable
+public class RoleImmunityId implements Serializable {
+    @Column(name = "role_id")
+    private Long roleId;
+    @Column(name = "effect_id")
+    private Long effectId;
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        RoleImmunityId that = (RoleImmunityId) o;
+        return Objects.equals(roleId, that.roleId) &&
+                Objects.equals(effectId, that.effectId);
+    }
+
+    public RoleImmunityId() {
+    }
+
+    public RoleImmunityId(Long roleId, Long effectId) {
+        this.roleId = roleId;
+        this.effectId = effectId;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(roleId, effectId);
+    }
+
+    public Long getRoleId() {
+        return roleId;
+    }
+
+    public void setRoleId(Long roleId) {
+        this.roleId = roleId;
+    }
+
+    public Long getEffectId() {
+        return effectId;
+    }
+
+    public void setEffectId(Long effectId) {
+        this.effectId = effectId;
+    }
+}

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/models/database/EffectType.java

@@ -0,0 +1,31 @@
+package dev.sheldan.abstracto.core.models.database;
+
+import lombok.*;
+
+import javax.persistence.*;
+import java.time.Instant;
+
+@Entity
+@Table(name = "effect_type")
+@Getter
+@Builder
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@EqualsAndHashCode
+public class EffectType {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "id")
+    private Long id;
+
+    @Column(name = "effect_type_key")
+    private String effectTypeKey;
+
+    @Column(name = "created")
+    private Instant created;
+
+    @Column(name = "updated")
+    private Instant updated;
+}

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/models/database/RoleImmunity.java

@@ -0,0 +1,41 @@
+package dev.sheldan.abstracto.core.models.database;
+
+import dev.sheldan.abstracto.core.models.RoleImmunityId;
+import lombok.*;
+
+import javax.persistence.*;
+import java.time.Instant;
+
+@Entity
+@Table(name = "role_immunity")
+@Getter
+@Builder
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@EqualsAndHashCode
+public class RoleImmunity {
+
+    @EmbeddedId
+    private RoleImmunityId immunityId;
+
+    @ManyToOne(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
+    @MapsId("effectId")
+    @JoinColumn(name = "effect_id", nullable = false)
+    private EffectType effect;
+
+    @ManyToOne(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
+    @MapsId("roleId")
+    @JoinColumn(name = "role_id", nullable = false)
+    private ARole role;
+
+    @OneToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name="server_id", nullable = false)
+    private AServer server;
+
+    @Column(name = "created")
+    private Instant created;
+
+    @Column(name = "updated")
+    private Instant updated;
+}

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/models/template/commands/ShowEffectsModel.java

@@ -0,0 +1,12 @@
+package dev.sheldan.abstracto.core.models.template.commands;
+
+import lombok.Builder;
+import lombok.Getter;
+
+import java.util.List;
+
+@Getter
+@Builder
+public class ShowEffectsModel {
+    private List<String> effects;
+}

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/models/template/commands/help/HelpCommandDetailsModel.java

@@ -18,7 +18,7 @@ public class HelpCommandDetailsModel extends UserInitiatedServerContext {
     private List<String> serverSpecificAliases;
     private String usage;
     private List<Role> allowedRoles;
-    private List<Role> immuneRoles;
     private Boolean restricted;
     private CommandCoolDownConfig cooldowns;
+    private List<String> effects;
 }

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/ChannelGroupService.java

@@ -21,6 +21,7 @@ public interface ChannelGroupService {
     void removeCommandFromChannelGroup(String commandName, String channelGroupName, Long serverId);
     void disableChannelGroup(String channelGroupName, Long serverId);
     void enableChannelGroup(String channelGroupName, Long serverId);
+    boolean isChannelInEnabledChannelGroupOfType(String channelGroupType, Long channelId);
     boolean doesGroupExist(String groupName, Long serverId);
     List<AChannelGroup> getChannelGroupsOfChannelWithType(AChannel channel, String groupTypeKey);
     List<ChannelGroupModel> convertAChannelGroupToChannelGroupChannel(List<AChannelGroup> channelGroups);

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/RoleImmunityService.java

@@ -0,0 +1,22 @@
+package dev.sheldan.abstracto.core.service;
+
+
+import dev.sheldan.abstracto.core.models.database.ARole;
+import dev.sheldan.abstracto.core.models.database.EffectType;
+import dev.sheldan.abstracto.core.models.database.RoleImmunity;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.Role;
+
+import java.util.Optional;
+
+public interface RoleImmunityService {
+    boolean isImmune(Member member, String effectTypeKey);
+    boolean isImmune(Member member, EffectType effectType);
+    Optional<RoleImmunity> getRoleImmunity(Member member, String effectType);
+    RoleImmunity makeRoleImmune(Role role, String effectType);
+    RoleImmunity makeRoleImmune(Role role, EffectType effectType);
+    void makeRoleAffected(Role role, String effectType);
+    void makeRoleAffected(ARole role, String effectType);
+    void makeRoleAffected(Role role, EffectType effectType);
+    void makeRoleAffected(ARole role, EffectType effectType);
+}

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/RoleService.java

@@ -8,6 +8,7 @@ import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.Role;
 
 import java.util.List;
+import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 
 public interface RoleService {
@@ -28,6 +29,7 @@ public interface RoleService {
     Role getRoleFromGuild(ARole role);
     List<Role> getRolesFromGuild(List<ARole> roles);
     boolean hasAnyOfTheRoles(Member member, List<ARole> roles);
+    Optional<ARole> getFirstRole(Member member, List<ARole> roles);
     boolean memberHasRole(Member member, Role role);
     boolean memberHasRole(Member member, ARole role);
     boolean memberHasRole(Member member, Long roleId);

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/management/ChannelGroupManagementService.java

@@ -24,4 +24,5 @@ public interface ChannelGroupManagementService {
     List<AChannelGroup> findAllInServer(Long serverId);
     List<AChannelGroup> getAllChannelGroupsOfChannel(AChannel channel);
     List<AChannelGroup> findAllInServerWithType(Long serverId, String type);
+    boolean isChannelInEnabledChannelGroupOfType(String channelGroupType, Long channelId);
 }

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/management/EffectTypeManagementService.java

@@ -0,0 +1,12 @@
+package dev.sheldan.abstracto.core.service.management;
+
+import dev.sheldan.abstracto.core.models.database.EffectType;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface EffectTypeManagementService {
+    Optional<EffectType> loadEffectTypeByKeyOptional(String effectType);
+    EffectType loadEffectTypeByKey(String effectType);
+    List<EffectType> getAllEffects();
+}

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/service/management/RoleImmunityManagementService.java

@@ -0,0 +1,18 @@
+package dev.sheldan.abstracto.core.service.management;
+
+import dev.sheldan.abstracto.core.models.database.ARole;
+import dev.sheldan.abstracto.core.models.database.AServer;
+import dev.sheldan.abstracto.core.models.database.EffectType;
+import dev.sheldan.abstracto.core.models.database.RoleImmunity;
+
+import java.util.List;
+import java.util.Optional;
+
+public interface RoleImmunityManagementService {
+    RoleImmunity makeRoleImmune(ARole role, EffectType effectType);
+    void makeRoleAffected(ARole role, EffectType effectType);
+    Optional<RoleImmunity> getRoleImmunity(ARole role, EffectType effectType);
+    Optional<RoleImmunity> getRoleImmunity(ARole role, String effectType);
+    List<RoleImmunity> getRolesImmuneAgainst(AServer server, String effectType);
+    List<RoleImmunity> getRolesImmuneAgainst(AServer server, EffectType effectType);
+}