commonMain.builder.automoderation.AutoModerationRuleModifyBuilder.kt Maven / Gradle / Ivy

Go to download
package dev.kord.rest.builder.automoderation

import dev.kord.common.annotation.KordDsl
import dev.kord.common.entity.*
import dev.kord.common.entity.optional.*
import dev.kord.common.entity.optional.delegate.delegate
import dev.kord.rest.builder.AuditRequestBuilder
import dev.kord.rest.json.request.AutoModerationRuleModifyRequest
import kotlin.contracts.InvocationKind.AT_MOST_ONCE
import kotlin.contracts.contract

/** An [AutoModerationRuleBuilder] for building [AutoModerationRuleModifyRequest]s. */
@KordDsl
public sealed class AutoModerationRuleModifyBuilder :
    AutoModerationRuleBuilder,
    AuditRequestBuilder {
    final override var reason: String? = null

    private var _name: Optional = Optional.Missing()
    final override var name: String? by ::_name.delegate()

    /** @suppress Use `this.name = name` instead. */
    final override fun assignName(name: String) {
        this.name = name
    }

    private var _eventType: Optional = Optional.Missing()
    final override var eventType: AutoModerationRuleEventType? by ::_eventType.delegate()

    /** @suppress Use `this.eventType = eventType` instead. */
    final override fun assignEventType(eventType: AutoModerationRuleEventType) {
        this.eventType = eventType
    }

    protected open fun buildTriggerMetadata(): Optional = Optional.Missing()

    private var _actions: Optional> = Optional.Missing()
    final override var actions: MutableList? by ::_actions.delegate()

    /** @suppress Use `this.actions = actions` instead. */
    final override fun assignActions(actions: MutableList) {
        this.actions = actions
    }

    private var _enabled: OptionalBoolean = OptionalBoolean.Missing
    final override var enabled: Boolean? by ::_enabled.delegate()

    private var _exemptRoles: Optional> = Optional.Missing()
    final override var exemptRoles: MutableList? by ::_exemptRoles.delegate()

    private var _exemptChannels: Optional> = Optional.Missing()
    final override var exemptChannels: MutableList? by ::_exemptChannels.delegate()

    final override fun toRequest(): AutoModerationRuleModifyRequest = AutoModerationRuleModifyRequest(
        name = _name,
        eventType = _eventType,
        triggerMetadata = buildTriggerMetadata(),
        actions = _actions.mapList { it.toRequest() },
        enabled = _enabled,
        exemptRoles = _exemptRoles.mapCopy(),
        exemptChannels = _exemptChannels.mapCopy(),
    )
}

/** An [AutoModerationRuleModifyBuilder] with an always `null` [triggerType]. */
@KordDsl
public class UntypedAutoModerationRuleModifyBuilder : AutoModerationRuleModifyBuilder() {

    /**
     * This is always `null`, the function that created this builder doesn't know the
     * [trigger type][AutoModerationRuleTriggerType] based on the type system.
     */
    override val triggerType: Nothing? get() = null
}

/** A [KeywordAutoModerationRuleBuilder] for building [AutoModerationRuleModifyRequest]s. */
@KordDsl
public class KeywordAutoModerationRuleModifyBuilder :
    AutoModerationRuleModifyBuilder(),
    KeywordAutoModerationRuleBuilder {

    private var _keywords: Optional> = Optional.Missing()
    override var keywords: MutableList? by ::_keywords.delegate()

    private var _regexPatterns: Optional> = Optional.Missing()
    override var regexPatterns: MutableList? by ::_regexPatterns.delegate()

    private var _allowedKeywords: Optional> = Optional.Missing()
    override var allowedKeywords: MutableList? by ::_allowedKeywords.delegate()

    override fun buildTriggerMetadata(): Optional {
        val keywords = _keywords
        val regexPatterns = _regexPatterns
        val allowedKeywords = _allowedKeywords
        return ifAnyPresent(keywords, regexPatterns, allowedKeywords) {
            DiscordAutoModerationRuleTriggerMetadata(
                keywordFilter = keywords.mapCopy(),
                regexPatterns = regexPatterns.mapCopy(),
                allowList = allowedKeywords.mapCopy(),
            )
        }
    }
}

/** A [SpamAutoModerationRuleBuilder] for building [AutoModerationRuleModifyRequest]s. */
@Suppress("CanSealedSubClassBeObject") // superclass is mutable
@KordDsl
public class SpamAutoModerationRuleModifyBuilder :
    AutoModerationRuleModifyBuilder(),
    SpamAutoModerationRuleBuilder

/** A [KeywordPresetAutoModerationRuleBuilder] for building [AutoModerationRuleModifyRequest]s. */
@KordDsl
public class KeywordPresetAutoModerationRuleModifyBuilder :
    AutoModerationRuleModifyBuilder(),
    KeywordPresetAutoModerationRuleBuilder {

    private var _presets: Optional> = Optional.Missing()
    override var presets: MutableList? by ::_presets.delegate()

    /** @suppress Use `this.presets = presets` instead. */
    @Deprecated(
        "Use 'this.presets = presets' instead. The deprecation level will be raised to ERROR in 0.16.0, to HIDDEN in " +
            "0.17.0, and this declaration will be removed in 0.18.0.",
        ReplaceWith("this.run { [email protected] = presets }", imports = ["kotlin.run"]),
        DeprecationLevel.WARNING,
    )
    override fun assignPresets(presets: MutableList) {
        this.presets = presets
    }

    private var _allowedKeywords: Optional> = Optional.Missing()
    override var allowedKeywords: MutableList? by ::_allowedKeywords.delegate()

    override fun buildTriggerMetadata(): Optional {
        val presets = _presets
        val allowedKeywords = _allowedKeywords
        return ifAnyPresent(presets, allowedKeywords) {
            DiscordAutoModerationRuleTriggerMetadata(
                presets = presets.mapCopy(),
                allowList = allowedKeywords.mapCopy(),
            )
        }
    }
}

/** A [MentionSpamAutoModerationRuleBuilder] for building [AutoModerationRuleModifyRequest]s. */
@KordDsl
public class MentionSpamAutoModerationRuleModifyBuilder :
    AutoModerationRuleModifyBuilder(),
    MentionSpamAutoModerationRuleBuilder {

    private var _mentionLimit: OptionalInt = OptionalInt.Missing
    override var mentionLimit: Int? by ::_mentionLimit.delegate()

    private var _mentionRaidProtectionEnabled: OptionalBoolean = OptionalBoolean.Missing
    override var mentionRaidProtectionEnabled: Boolean? by ::_mentionRaidProtectionEnabled.delegate()

    override fun buildTriggerMetadata(): Optional {
        val mentionLimit = _mentionLimit
        val mentionRaidProtectionEnabled = _mentionRaidProtectionEnabled
        return if (mentionLimit is OptionalInt.Value || mentionRaidProtectionEnabled is OptionalBoolean.Value) {
            DiscordAutoModerationRuleTriggerMetadata(
                mentionTotalLimit = mentionLimit,
                mentionRaidProtectionEnabled = mentionRaidProtectionEnabled,
            ).optional()
        } else {
            Optional.Missing()
        }
    }
}

/** A [MemberProfileAutoModerationRuleBuilder] for building [AutoModerationRuleModifyRequest]s. */
@KordDsl
public class MemberProfileAutoModerationRuleModifyBuilder :
    AutoModerationRuleModifyBuilder(),
    MemberProfileAutoModerationRuleBuilder {

    private var _keywords: Optional> = Optional.Missing()
    override var keywords: MutableList? by ::_keywords.delegate()

    private var _regexPatterns: Optional> = Optional.Missing()
    override var regexPatterns: MutableList? by ::_regexPatterns.delegate()

    private var _allowedKeywords: Optional> = Optional.Missing()
    override var allowedKeywords: MutableList? by ::_allowedKeywords.delegate()

    override fun buildTriggerMetadata(): Optional {
        val keywords = _keywords
        val regexPatterns = _regexPatterns
        val allowedKeywords = _allowedKeywords
        return ifAnyPresent(keywords, regexPatterns, allowedKeywords) {
            DiscordAutoModerationRuleTriggerMetadata(
                keywordFilter = keywords.mapCopy(),
                regexPatterns = regexPatterns.mapCopy(),
                allowList = allowedKeywords.mapCopy(),
            )
        }
    }
}

private inline fun  ifAnyPresent(vararg optionals: Optional<*>, block: () -> T): Optional {
    contract { callsInPlace(block, AT_MOST_ONCE) }

    return if (optionals.any { it is Optional.Value }) {
        Optional.Value(block())
    } else {
        Optional.Missing()
    }
}