diff --git a/core/common/build.gradle.kts b/core/common/build.gradle.kts index 1533f9745..0c902c6dc 100644 --- a/core/common/build.gradle.kts +++ b/core/common/build.gradle.kts @@ -43,6 +43,7 @@ dependencies { compileOnly("com.nexomc:nexo:1.17.0") { exclude(group = "*", module = "*") } + compileOnly("net.luckperms:api:5.4") compileOnly(fileTree("../../lib") { include("*.jar") diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/LibreforgeSpigotPlugin.kt b/core/common/src/main/kotlin/com/willfp/libreforge/LibreforgeSpigotPlugin.kt index 3c053bd9e..5bec4b28f 100644 --- a/core/common/src/main/kotlin/com/willfp/libreforge/LibreforgeSpigotPlugin.kt +++ b/core/common/src/main/kotlin/com/willfp/libreforge/LibreforgeSpigotPlugin.kt @@ -31,6 +31,7 @@ import com.willfp.libreforge.integrations.huskintegration.husktowns.HuskTownsInt import com.willfp.libreforge.integrations.jobs.JobsIntegration import com.willfp.libreforge.integrations.lands.LandsIntegration import com.willfp.libreforge.integrations.levelledmobs.LevelledMobsIntegration +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration import com.willfp.libreforge.integrations.mcmmo.McMMOIntegration import com.willfp.libreforge.integrations.modelengine.ModelEngineIntegration import com.willfp.libreforge.integrations.mythicmobs.MythicMobsIntegration @@ -232,7 +233,8 @@ class LibreforgeSpigotPlugin : EcoPlugin() { IntegrationLoader("EdPrison") { EdPrisonCoreIntegration.load(this) }, IntegrationLoader("MythicMobs") { MythicMobsIntegration.load(this) }, IntegrationLoader("Nexo") { NexoIntegration.load(this) }, - IntegrationLoader("Oraxen") { OraxenIntegration.load(this)} + IntegrationLoader("Oraxen") { OraxenIntegration.load(this) }, + IntegrationLoader("LuckPerms") { LuckPermsIntegration.load(this) } ) } diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/LuckPermsIntegration.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/LuckPermsIntegration.kt new file mode 100644 index 000000000..91c471c05 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/LuckPermsIntegration.kt @@ -0,0 +1,79 @@ +package com.willfp.libreforge.integrations.luckperms + +import com.willfp.eco.core.EcoPlugin +import com.willfp.libreforge.conditions.Conditions +import com.willfp.libreforge.effects.Effects +import com.willfp.libreforge.integrations.LoadableIntegration +import com.willfp.libreforge.integrations.luckperms.impl.group.ConditionLuckPermInGroup +import com.willfp.libreforge.integrations.luckperms.impl.group.EffectLuckPermDisinheritGroup +import com.willfp.libreforge.integrations.luckperms.impl.group.EffectLuckPermInheritGroup +import com.willfp.libreforge.integrations.luckperms.impl.group.TriggerLuckPermsGroupChange +import com.willfp.libreforge.integrations.luckperms.impl.group.TriggerLuckPermsGroupDisinherit +import com.willfp.libreforge.integrations.luckperms.impl.group.TriggerLuckPermsGroupInherit +import com.willfp.libreforge.integrations.luckperms.impl.meta.ConditionLuckPermCheckMeta +import com.willfp.libreforge.integrations.luckperms.impl.meta.EffectLuckPermRemoveMeta +import com.willfp.libreforge.integrations.luckperms.impl.meta.EffectLuckPermSetMeta +import com.willfp.libreforge.integrations.luckperms.impl.meta.TriggerLuckPermsMetaAdd +import com.willfp.libreforge.integrations.luckperms.impl.meta.TriggerLuckPermsMetaChange +import com.willfp.libreforge.integrations.luckperms.impl.meta.TriggerLuckPermsMetaRemove +import com.willfp.libreforge.integrations.luckperms.impl.perms.ConditionLuckPermHasPermission +import com.willfp.libreforge.integrations.luckperms.impl.perms.EffectLuckPermGivePermission +import com.willfp.libreforge.integrations.luckperms.impl.perms.EffectLuckPermRemovePermission +import com.willfp.libreforge.integrations.luckperms.impl.perms.EffectLuckPermSetPermission +import com.willfp.libreforge.integrations.luckperms.impl.perms.TriggerLuckPermsPermissionAdd +import com.willfp.libreforge.integrations.luckperms.impl.perms.TriggerLuckPermsPermissionChange +import com.willfp.libreforge.integrations.luckperms.impl.perms.TriggerLuckPermsPermissionRemove +import com.willfp.libreforge.integrations.luckperms.impl.regex.EffectLuckPermGiveRegexPermission +import com.willfp.libreforge.integrations.luckperms.impl.regex.EffectLuckPermRemoveRegexPermission +import com.willfp.libreforge.integrations.luckperms.impl.regex.EffectLuckPermSetRegexPermission +import com.willfp.libreforge.integrations.luckperms.impl.regex.TriggerLuckPermsRegexPermissionAdd +import com.willfp.libreforge.integrations.luckperms.impl.regex.TriggerLuckPermsRegexPermissionChange +import com.willfp.libreforge.integrations.luckperms.impl.regex.TriggerLuckPermsRegexPermissionRemove +import com.willfp.libreforge.triggers.Triggers +import net.luckperms.api.LuckPermsProvider +import net.luckperms.api.model.user.User +import org.bukkit.entity.Player + +object LuckPermsIntegration : LoadableIntegration { + override fun load(plugin: EcoPlugin) { + Conditions.register(ConditionLuckPermHasPermission) + Conditions.register(ConditionLuckPermCheckMeta) + Conditions.register(ConditionLuckPermInGroup) + // + Effects.register(EffectLuckPermGivePermission) + Effects.register(EffectLuckPermSetPermission) + Effects.register(EffectLuckPermRemovePermission) + Effects.register(EffectLuckPermGiveRegexPermission) + Effects.register(EffectLuckPermSetRegexPermission) + Effects.register(EffectLuckPermRemoveRegexPermission) + Effects.register(EffectLuckPermSetMeta) + Effects.register(EffectLuckPermRemoveMeta) + Effects.register(EffectLuckPermInheritGroup) + Effects.register(EffectLuckPermDisinheritGroup) + // + Triggers.register(TriggerLuckPermsPermissionAdd) + Triggers.register(TriggerLuckPermsPermissionChange) + Triggers.register(TriggerLuckPermsPermissionRemove) + Triggers.register(TriggerLuckPermsRegexPermissionAdd) + Triggers.register(TriggerLuckPermsRegexPermissionChange) + Triggers.register(TriggerLuckPermsRegexPermissionRemove) + Triggers.register(TriggerLuckPermsMetaAdd) + Triggers.register(TriggerLuckPermsMetaChange) + Triggers.register(TriggerLuckPermsMetaRemove) + Triggers.register(TriggerLuckPermsGroupInherit) + Triggers.register(TriggerLuckPermsGroupDisinherit) + Triggers.register(TriggerLuckPermsGroupChange) + } + + override fun getPluginName(): String { + return "LuckPerms" + } + + fun Player.getLuckPermsUser(): User? { + return LuckPermsProvider.get().userManager.getUser(uniqueId) + } + + fun User.saveChanges() { + LuckPermsProvider.get().userManager.saveUser(this) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/ConditionLuckPermInGroup.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/ConditionLuckPermInGroup.kt new file mode 100644 index 000000000..517feaf62 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/ConditionLuckPermInGroup.kt @@ -0,0 +1,36 @@ +package com.willfp.libreforge.integrations.luckperms.impl.group + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.Dispatcher +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.ProvidedHolder +import com.willfp.libreforge.arguments +import com.willfp.libreforge.conditions.Condition +import com.willfp.libreforge.get +import com.willfp.libreforge.getFormattedStrings +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import net.luckperms.api.node.NodeType +import net.luckperms.api.node.types.InheritanceNode +import org.bukkit.entity.Player + +object ConditionLuckPermInGroup : Condition("in_group") { + override val arguments = arguments { + require(listOf("group", "groups"), "You must specify the group(s)!") + } + + override fun isMet( + dispatcher: Dispatcher<*>, + config: Config, + holder: ProvidedHolder, + compileData: NoCompileData + ): Boolean { + val player = dispatcher.get() ?: return false + val user = player.getLuckPermsUser() ?: return false + + val groups = config.getFormattedStrings("groups", "group") + + return user.getNodes(NodeType.INHERITANCE) + .map(InheritanceNode::getGroupName) + .containsAll(groups) + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/EffectLuckPermDisinheritGroup.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/EffectLuckPermDisinheritGroup.kt new file mode 100644 index 000000000..eb4b5b949 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/EffectLuckPermDisinheritGroup.kt @@ -0,0 +1,46 @@ +package com.willfp.libreforge.integrations.luckperms.impl.group + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import com.willfp.libreforge.triggers.TriggerData +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.InheritanceNode + +object EffectLuckPermDisinheritGroup : Effect("disinherit_group") { + override val arguments = arguments { + require("group", "You must specify the group!") + } + + override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean { + val player = data.player ?: return false + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return false + } + + val user = player.getLuckPermsUser() ?: return false + val group = config.getFormattedString("group") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = InheritanceNode.builder(group) + .value(true) + .context(contextSet.build()) + .build() + + user.data().remove(node) + user.saveChanges() + return true + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/EffectLuckPermInheritGroup.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/EffectLuckPermInheritGroup.kt new file mode 100644 index 000000000..18b49b15f --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/EffectLuckPermInheritGroup.kt @@ -0,0 +1,53 @@ +package com.willfp.libreforge.integrations.luckperms.impl.group + +import com.nexomc.nexo.utils.applyIf +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import com.willfp.libreforge.triggers.TriggerData +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.InheritanceNode +import java.time.Duration + +object EffectLuckPermInheritGroup : Effect("inherit_group") { + override val arguments = arguments { + require("group", "You must specify the permission!") + } + + override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean { + val player = data.player ?: return false + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return false + } + + val user = player.getLuckPermsUser() ?: return false + val group = config.getFormattedString("group") + val value = config.getBoolOrNull("value") + val expiry = config.getIntOrNull("expiry") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = InheritanceNode.builder(group) + .value(value ?: true) + .context(contextSet.build()) + .applyIf(expiry != null && expiry > 0) { + expiry(Duration.ofSeconds(expiry?.toLong() ?: 0)) + } + .build() + + user.data().add(node) + user.saveChanges() + return true + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupChange.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupChange.kt new file mode 100644 index 000000000..9ebe74171 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupChange.kt @@ -0,0 +1,24 @@ +package com.willfp.libreforge.integrations.luckperms.impl.group + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import org.bukkit.entity.Player + +object TriggerLuckPermsGroupChange : Trigger("group_changed") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + fun dispatch(player: Player, group: String) { + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = group + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupDisinherit.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupDisinherit.kt new file mode 100644 index 000000000..06c1fcfe2 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupDisinherit.kt @@ -0,0 +1,35 @@ +package com.willfp.libreforge.integrations.luckperms.impl.group + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import net.luckperms.api.event.node.NodeRemoveEvent +import net.luckperms.api.model.user.User +import net.luckperms.api.node.types.InheritanceNode +import org.bukkit.Bukkit +import org.bukkit.event.EventHandler + +object TriggerLuckPermsGroupDisinherit : Trigger("group_disinherited") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + @EventHandler(ignoreCancelled = true) + fun handle(event: NodeRemoveEvent) { + if (!event.isUser) return + val player = Bukkit.getPlayer((event.target as User).uniqueId) ?: return + val node = event.node as? InheritanceNode ?: return + + TriggerLuckPermsGroupChange.dispatch(player, node.groupName) + + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = node.groupName + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupInherit.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupInherit.kt new file mode 100644 index 000000000..3424ff7ee --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/group/TriggerLuckPermsGroupInherit.kt @@ -0,0 +1,35 @@ +package com.willfp.libreforge.integrations.luckperms.impl.group + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import net.luckperms.api.event.node.NodeAddEvent +import net.luckperms.api.model.user.User +import net.luckperms.api.node.types.InheritanceNode +import org.bukkit.Bukkit +import org.bukkit.event.EventHandler + +object TriggerLuckPermsGroupInherit : Trigger("group_inherited") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + @EventHandler(ignoreCancelled = true) + fun handle(event: NodeAddEvent) { + if (!event.isUser) return + val player = Bukkit.getPlayer((event.target as User).uniqueId) ?: return + val node = event.node as? InheritanceNode ?: return + + TriggerLuckPermsGroupChange.dispatch(player, node.groupName) + + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = node.groupName + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/ConditionLuckPermCheckMeta.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/ConditionLuckPermCheckMeta.kt new file mode 100644 index 000000000..bd9478752 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/ConditionLuckPermCheckMeta.kt @@ -0,0 +1,32 @@ +package com.willfp.libreforge.integrations.luckperms.impl.meta + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.Dispatcher +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.ProvidedHolder +import com.willfp.libreforge.arguments +import com.willfp.libreforge.conditions.Condition +import com.willfp.libreforge.get +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import org.bukkit.entity.Player + +object ConditionLuckPermCheckMeta : Condition("check_meta") { + override val arguments = arguments { + require("key", "You must specify the key!") + require("value", "You must specify the value!") + } + + override fun isMet( + dispatcher: Dispatcher<*>, + config: Config, + holder: ProvidedHolder, + compileData: NoCompileData + ): Boolean { + val player = dispatcher.get() ?: return false + val user = player.getLuckPermsUser() ?: return false + + return user.cachedData.metaData + .getMetaValue(config.getFormattedString("key")) + .equals(config.getFormattedString("value"), ignoreCase = true) + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/EffectLuckPermRemoveMeta.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/EffectLuckPermRemoveMeta.kt new file mode 100644 index 000000000..95e68dce1 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/EffectLuckPermRemoveMeta.kt @@ -0,0 +1,47 @@ +package com.willfp.libreforge.integrations.luckperms.impl.meta + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import com.willfp.libreforge.triggers.TriggerData +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.MetaNode + +object EffectLuckPermRemoveMeta : Effect("remove_meta") { + override val arguments = arguments { + require("key", "You must specify the key!") + require("value", "You must specify the value!") + } + + override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean { + val player = data.player ?: return false + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return false + } + + val user = player.getLuckPermsUser() ?: return false + val key = config.getFormattedString("key") + val value = config.getFormattedString("value") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = MetaNode.builder(key, value) + .context(contextSet.build()) + .build() + + user.data().remove(node) + user.saveChanges() + return true + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/EffectLuckPermSetMeta.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/EffectLuckPermSetMeta.kt new file mode 100644 index 000000000..25f9a0123 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/EffectLuckPermSetMeta.kt @@ -0,0 +1,53 @@ +package com.willfp.libreforge.integrations.luckperms.impl.meta + +import com.nexomc.nexo.utils.applyIf +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import com.willfp.libreforge.triggers.TriggerData +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.MetaNode +import java.time.Duration + +object EffectLuckPermSetMeta : Effect("set_meta") { + override val arguments = arguments { + require("key", "You must specify the key!") + require("value", "You must specify the value!") + } + + override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean { + val player = data.player ?: return false + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return false + } + + val user = player.getLuckPermsUser() ?: return false + val key = config.getFormattedString("key") + val value = config.getFormattedString("value") + val expiry = config.getIntOrNull("expiry") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = MetaNode.builder(key, value) + .context(contextSet.build()) + .applyIf(expiry != null && expiry > 0) { + expiry(Duration.ofSeconds(expiry?.toLong() ?: 0)) + } + .build() + + user.data().add(node) + user.saveChanges() + return true + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaAdd.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaAdd.kt new file mode 100644 index 000000000..312f3e298 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaAdd.kt @@ -0,0 +1,35 @@ +package com.willfp.libreforge.integrations.luckperms.impl.meta + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import net.luckperms.api.event.node.NodeAddEvent +import net.luckperms.api.model.user.User +import net.luckperms.api.node.types.MetaNode +import org.bukkit.Bukkit +import org.bukkit.event.EventHandler + +object TriggerLuckPermsMetaAdd : Trigger("meta_added") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + @EventHandler(ignoreCancelled = true) + fun handle(event: NodeAddEvent) { + if (!event.isUser) return + val player = Bukkit.getPlayer((event.target as User).uniqueId) ?: return + val node = event.node as? MetaNode ?: return + + TriggerLuckPermsMetaChange.dispatch(player, node.metaKey, node.metaValue) + + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = "${node.metaKey}:${node.metaValue}" + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaChange.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaChange.kt new file mode 100644 index 000000000..5b52a4ab9 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaChange.kt @@ -0,0 +1,24 @@ +package com.willfp.libreforge.integrations.luckperms.impl.meta + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import org.bukkit.entity.Player + +object TriggerLuckPermsMetaChange : Trigger("meta_changed") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + fun dispatch(player: Player, key: String, value: String) { + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = "$key:$value" + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaRemove.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaRemove.kt new file mode 100644 index 000000000..b14ed120b --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/meta/TriggerLuckPermsMetaRemove.kt @@ -0,0 +1,35 @@ +package com.willfp.libreforge.integrations.luckperms.impl.meta + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import net.luckperms.api.event.node.NodeRemoveEvent +import net.luckperms.api.model.user.User +import net.luckperms.api.node.types.MetaNode +import org.bukkit.Bukkit +import org.bukkit.event.EventHandler + +object TriggerLuckPermsMetaRemove : Trigger("meta_removed") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + @EventHandler(ignoreCancelled = true) + fun handle(event: NodeRemoveEvent) { + if (!event.isUser) return + val player = Bukkit.getPlayer((event.target as User).uniqueId) ?: return + val node = event.node as? MetaNode ?: return + + TriggerLuckPermsMetaChange.dispatch(player, node.metaKey, node.metaValue) + + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = "${node.metaKey}:${node.metaValue}" + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/ConditionLuckPermHasPermission.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/ConditionLuckPermHasPermission.kt new file mode 100644 index 000000000..65d5f29cf --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/ConditionLuckPermHasPermission.kt @@ -0,0 +1,34 @@ +package com.willfp.libreforge.integrations.luckperms.impl.perms + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.Dispatcher +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.ProvidedHolder +import com.willfp.libreforge.arguments +import com.willfp.libreforge.conditions.Condition +import com.willfp.libreforge.get +import com.willfp.libreforge.getFormattedStrings +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import org.bukkit.entity.Player + +object ConditionLuckPermHasPermission : Condition("has_permission") { + override val arguments = arguments { + require(listOf("permission", "permissions"), "You must specify the permission(s)!") + } + + override fun isMet( + dispatcher: Dispatcher<*>, + config: Config, + holder: ProvidedHolder, + compileData: NoCompileData + ): Boolean { + val player = dispatcher.get() ?: return false + val user = player.getLuckPermsUser() ?: return false + + val cached = user.cachedData.permissionData + + val permissions = config.getFormattedStrings("permissions", "permission") + + return permissions.all { cached.checkPermission(it).asBoolean() } + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermGivePermission.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermGivePermission.kt new file mode 100644 index 000000000..c8c818022 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermGivePermission.kt @@ -0,0 +1,87 @@ +package com.willfp.libreforge.integrations.luckperms.impl.perms + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.eco.core.map.listMap +import com.willfp.libreforge.Dispatcher +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.ProvidedHolder +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.effects.Identifiers +import com.willfp.libreforge.get +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.PermissionNode +import org.bukkit.entity.Player +import java.util.UUID + +object EffectLuckPermGivePermission : Effect("give_permission") { + override val arguments = arguments { + require("permission", "You must specify the permission!") + } + + private val permissions = listMap() + + override fun onEnable( + dispatcher: Dispatcher<*>, + config: Config, + identifiers: Identifiers, + holder: ProvidedHolder, + compileData: NoCompileData + ) { + val player = dispatcher.get() ?: return + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return + } + + val user = player.getLuckPermsUser() ?: return + val permission = config.getFormattedString("permission") + val value = config.getBoolOrNull("value") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = PermissionNode.builder(permission) + .value(value ?: true) + .context(contextSet.build()) + .build() + + permissions[player.uniqueId].add(GivenPermission(node, player.uniqueId)) + user.data().add(node) + user.saveChanges() + } + + override fun onDisable(dispatcher: Dispatcher<*>, identifiers: Identifiers, holder: ProvidedHolder) { + val player = dispatcher.get() ?: return + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return + } + + val user = player.getLuckPermsUser() ?: return + val permission = permissions[player.uniqueId] + .firstOrNull { it.uuid == identifiers.uuid } ?: return + + permissions[player.uniqueId].remove(permission) + + // Remove the permission only if no other effect is giving it + if (permissions[dispatcher.uuid].none { it.node == permission.node }) { + user.data().remove(permission.node) + user.saveChanges() + } + } + + private data class GivenPermission( + val node: PermissionNode, + val uuid: UUID + ) +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermRemovePermission.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermRemovePermission.kt new file mode 100644 index 000000000..8c37dfaf1 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermRemovePermission.kt @@ -0,0 +1,46 @@ +package com.willfp.libreforge.integrations.luckperms.impl.perms + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import com.willfp.libreforge.triggers.TriggerData +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.PermissionNode + +object EffectLuckPermRemovePermission : Effect("remove_permission") { + override val arguments = arguments { + require("permission", "You must specify the permission!") + } + + override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean { + val player = data.player ?: return false + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return false + } + + val user = player.getLuckPermsUser() ?: return false + val permission = config.getFormattedString("permission") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = PermissionNode.builder(permission) + .value(true) + .context(contextSet.build()) + .build() + + user.data().remove(node) + user.saveChanges() + return true + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermSetPermission.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermSetPermission.kt new file mode 100644 index 000000000..091a39140 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/EffectLuckPermSetPermission.kt @@ -0,0 +1,53 @@ +package com.willfp.libreforge.integrations.luckperms.impl.perms + +import com.nexomc.nexo.utils.applyIf +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import com.willfp.libreforge.triggers.TriggerData +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.PermissionNode +import java.time.Duration + +object EffectLuckPermSetPermission : Effect("set_permission") { + override val arguments = arguments { + require("permission", "You must specify the permission!") + } + + override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean { + val player = data.player ?: return false + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return false + } + + val user = player.getLuckPermsUser() ?: return false + val permission = config.getFormattedString("permission") + val value = config.getBoolOrNull("value") + val expiry = config.getIntOrNull("expiry") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = PermissionNode.builder(permission) + .value(value ?: true) + .context(contextSet.build()) + .applyIf(expiry != null && expiry > 0) { + expiry(Duration.ofSeconds(expiry?.toLong() ?: 0)) + } + .build() + + user.data().add(node) + user.saveChanges() + return true + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionAdd.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionAdd.kt new file mode 100644 index 000000000..f709a7dc9 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionAdd.kt @@ -0,0 +1,35 @@ +package com.willfp.libreforge.integrations.luckperms.impl.perms + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import net.luckperms.api.event.node.NodeAddEvent +import net.luckperms.api.model.user.User +import net.luckperms.api.node.types.PermissionNode +import org.bukkit.Bukkit +import org.bukkit.event.EventHandler + +object TriggerLuckPermsPermissionAdd : Trigger("permission_added") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + @EventHandler(ignoreCancelled = true) + fun handle(event: NodeAddEvent) { + if (!event.isUser) return + val player = Bukkit.getPlayer((event.target as User).uniqueId) ?: return + val node = event.node as? PermissionNode ?: return + + TriggerLuckPermsPermissionChange.dispatch(player, node.permission) + + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = node.permission + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionChange.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionChange.kt new file mode 100644 index 000000000..45adc75c6 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionChange.kt @@ -0,0 +1,24 @@ +package com.willfp.libreforge.integrations.luckperms.impl.perms + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import org.bukkit.entity.Player + +object TriggerLuckPermsPermissionChange : Trigger("permission_changed") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + fun dispatch(player: Player, permission: String) { + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = permission + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionRemove.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionRemove.kt new file mode 100644 index 000000000..ebab5d58d --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/perms/TriggerLuckPermsPermissionRemove.kt @@ -0,0 +1,35 @@ +package com.willfp.libreforge.integrations.luckperms.impl.perms + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import net.luckperms.api.event.node.NodeRemoveEvent +import net.luckperms.api.model.user.User +import net.luckperms.api.node.types.PermissionNode +import org.bukkit.Bukkit +import org.bukkit.event.EventHandler + +object TriggerLuckPermsPermissionRemove : Trigger("permission_removed") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + @EventHandler(ignoreCancelled = true) + fun handle(event: NodeRemoveEvent) { + if (!event.isUser) return + val player = Bukkit.getPlayer((event.target as User).uniqueId) ?: return + val node = event.node as? PermissionNode ?: return + + TriggerLuckPermsPermissionChange.dispatch(player, node.permission) + + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = node.permission + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermGiveRegexPermission.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermGiveRegexPermission.kt new file mode 100644 index 000000000..13ec7dce1 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermGiveRegexPermission.kt @@ -0,0 +1,88 @@ +package com.willfp.libreforge.integrations.luckperms.impl.regex + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.eco.core.map.listMap +import com.willfp.eco.util.PatternUtils +import com.willfp.libreforge.Dispatcher +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.ProvidedHolder +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.effects.Identifiers +import com.willfp.libreforge.get +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.RegexPermissionNode +import org.bukkit.entity.Player +import java.util.UUID + +object EffectLuckPermGiveRegexPermission : Effect("give_regex_permission") { + override val arguments = arguments { + require("permission", "You must specify the permission!") + } + + private val permissions = listMap() + + override fun onEnable( + dispatcher: Dispatcher<*>, + config: Config, + identifiers: Identifiers, + holder: ProvidedHolder, + compileData: NoCompileData + ) { + val player = dispatcher.get() ?: return + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return + } + + val user = player.getLuckPermsUser() ?: return + val permission = PatternUtils.compileLiteral(config.getFormattedString("permission")) + val value = config.getBoolOrNull("value") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = RegexPermissionNode.builder(permission) + .value(value ?: true) + .context(contextSet.build()) + .build() + + permissions[player.uniqueId].add(GivenPermission(node, player.uniqueId)) + user.data().add(node) + user.saveChanges() + } + + override fun onDisable(dispatcher: Dispatcher<*>, identifiers: Identifiers, holder: ProvidedHolder) { + val player = dispatcher.get() ?: return + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return + } + + val user = player.getLuckPermsUser() ?: return + val permission = permissions[player.uniqueId] + .firstOrNull { it.uuid == identifiers.uuid } ?: return + + permissions[player.uniqueId].remove(permission) + + // Remove the permission only if no other effect is giving it + if (permissions[dispatcher.uuid].none { it.node == permission.node }) { + user.data().remove(permission.node) + user.saveChanges() + } + } + + private data class GivenPermission( + val node: RegexPermissionNode, + val uuid: UUID + ) +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermRemoveRegexPermission.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermRemoveRegexPermission.kt new file mode 100644 index 000000000..c21bde3a0 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermRemoveRegexPermission.kt @@ -0,0 +1,47 @@ +package com.willfp.libreforge.integrations.luckperms.impl.regex + +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.eco.util.PatternUtils +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import com.willfp.libreforge.triggers.TriggerData +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.RegexPermissionNode + +object EffectLuckPermRemoveRegexPermission : Effect("remove_regex_permission") { + override val arguments = arguments { + require("permission", "You must specify the permission!") + } + + override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean { + val player = data.player ?: return false + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return false + } + + val user = player.getLuckPermsUser() ?: return false + val permission = PatternUtils.compileLiteral(config.getFormattedString("permission")) + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = RegexPermissionNode.builder(permission) + .value(true) + .context(contextSet.build()) + .build() + + user.data().remove(node) + user.saveChanges() + return true + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermSetRegexPermission.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermSetRegexPermission.kt new file mode 100644 index 000000000..0b4b58d46 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/EffectLuckPermSetRegexPermission.kt @@ -0,0 +1,54 @@ +package com.willfp.libreforge.integrations.luckperms.impl.regex + +import com.nexomc.nexo.utils.applyIf +import com.willfp.eco.core.config.interfaces.Config +import com.willfp.eco.util.PatternUtils +import com.willfp.libreforge.NoCompileData +import com.willfp.libreforge.arguments +import com.willfp.libreforge.effects.Effect +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.getLuckPermsUser +import com.willfp.libreforge.integrations.luckperms.LuckPermsIntegration.saveChanges +import com.willfp.libreforge.triggers.TriggerData +import net.luckperms.api.context.ImmutableContextSet +import net.luckperms.api.node.types.RegexPermissionNode +import java.time.Duration + +object EffectLuckPermSetRegexPermission : Effect("set_regex_permission") { + override val arguments = arguments { + require("permission", "You must specify the permission!") + } + + override fun onTrigger(config: Config, data: TriggerData, compileData: NoCompileData): Boolean { + val player = data.player ?: return false + + // UUID Version 2 = NPC + if (player.uniqueId.version() == 2) { + return false + } + + val user = player.getLuckPermsUser() ?: return false + val permission = PatternUtils.compileLiteral(config.getFormattedString("permission")) + val value = config.getBoolOrNull("value") + val expiry = config.getIntOrNull("expiry") + val context = config.getFormattedStrings("context") + val contextSet = ImmutableContextSet.builder() + + for (string in context) { + val split = string.split(":") + if (split.size != 2) continue + contextSet.add(split[0], split[1]) + } + + val node = RegexPermissionNode.builder(permission) + .value(value ?: true) + .context(contextSet.build()) + .applyIf(expiry != null && expiry > 0) { + expiry(Duration.ofSeconds(expiry?.toLong() ?: 0)) + } + .build() + + user.data().add(node) + user.saveChanges() + return true + } +} \ No newline at end of file diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionAdd.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionAdd.kt new file mode 100644 index 000000000..55b8a64ea --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionAdd.kt @@ -0,0 +1,35 @@ +package com.willfp.libreforge.integrations.luckperms.impl.regex + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import net.luckperms.api.event.node.NodeAddEvent +import net.luckperms.api.model.user.User +import net.luckperms.api.node.types.RegexPermissionNode +import org.bukkit.Bukkit +import org.bukkit.event.EventHandler + +object TriggerLuckPermsRegexPermissionAdd : Trigger("regex_permission_added") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + @EventHandler(ignoreCancelled = true) + fun handle(event: NodeAddEvent) { + if (!event.isUser) return + val player = Bukkit.getPlayer((event.target as User).uniqueId) ?: return + val node = event.node as? RegexPermissionNode ?: return + + TriggerLuckPermsRegexPermissionChange.dispatch(player, node.patternString) + + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = node.patternString + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionChange.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionChange.kt new file mode 100644 index 000000000..4eb73636b --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionChange.kt @@ -0,0 +1,24 @@ +package com.willfp.libreforge.integrations.luckperms.impl.regex + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import org.bukkit.entity.Player + +object TriggerLuckPermsRegexPermissionChange : Trigger("regex_permission_changed") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + fun dispatch(player: Player, regex: String) { + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = regex + ) + ) + } +} diff --git a/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionRemove.kt b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionRemove.kt new file mode 100644 index 000000000..0e01a6526 --- /dev/null +++ b/core/common/src/main/kotlin/com/willfp/libreforge/integrations/luckperms/impl/regex/TriggerLuckPermsRegexPermissionRemove.kt @@ -0,0 +1,35 @@ +package com.willfp.libreforge.integrations.luckperms.impl.regex + +import com.willfp.libreforge.toDispatcher +import com.willfp.libreforge.triggers.Trigger +import com.willfp.libreforge.triggers.TriggerData +import com.willfp.libreforge.triggers.TriggerParameter +import net.luckperms.api.event.node.NodeRemoveEvent +import net.luckperms.api.model.user.User +import net.luckperms.api.node.types.RegexPermissionNode +import org.bukkit.Bukkit +import org.bukkit.event.EventHandler + +object TriggerLuckPermsRegexPermissionRemove : Trigger("regex_permission_removed") { + override val parameters = setOf( + TriggerParameter.PLAYER, + TriggerParameter.TEXT + ) + + @EventHandler(ignoreCancelled = true) + fun handle(event: NodeRemoveEvent) { + if (!event.isUser) return + val player = Bukkit.getPlayer((event.target as User).uniqueId) ?: return + val node = event.node as? RegexPermissionNode ?: return + + TriggerLuckPermsRegexPermissionChange.dispatch(player, node.patternString) + + this.dispatch( + player.toDispatcher(), + TriggerData( + player = player, + text = node.patternString + ) + ) + } +} diff --git a/core/common/src/main/resources/plugin.yml b/core/common/src/main/resources/plugin.yml index e400ad98e..e9301c12d 100644 --- a/core/common/src/main/resources/plugin.yml +++ b/core/common/src/main/resources/plugin.yml @@ -36,6 +36,7 @@ softdepend: - CustomFishing - Lands - EdPrison + - LuckPerms commands: lrcdb: