Add luckperms integration

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")

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) }
         )
     }
 

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)
+    }
+}

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<NoCompileData>("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<Player>() ?: return false
+        val user = player.getLuckPermsUser() ?: return false
+
+        val groups = config.getFormattedStrings("groups", "group")
+
+        return user.getNodes(NodeType.INHERITANCE)
+            .map(InheritanceNode::getGroupName)
+            .containsAll(groups)
+    }
+}

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<NoCompileData>("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
+    }
+}

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<NoCompileData>("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
+    }
+}

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
+            )
+        )
+    }
+}

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
+            )
+        )
+    }
+}

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
+            )
+        )
+    }
+}

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<NoCompileData>("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<Player>() ?: return false
+        val user = player.getLuckPermsUser() ?: return false
+
+        return user.cachedData.metaData
+            .getMetaValue(config.getFormattedString("key"))
+            .equals(config.getFormattedString("value"), ignoreCase = true)
+    }
+}