eightball/PluralKit
1
0
Fork 0
mirror of https://github.com/PluralKit/PluralKit.git synced 2026-02-05 13:27:54 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

implement random commands, dont keep the subcommands only the flags

Browse source
This commit is contained in:
dusk 2025-09-26 23:56:49 +00:00
parent c00ff2f371
commit c92c3f84f0
No known key found for this signature in database
13 changed files with 82 additions and 24 deletions
Download patch file Download diff file Expand all files Collapse all files

19
PluralKit.Bot/CommandMeta/CommandTree.cs
View file

@ -162,6 +162,15 @@ public partial class CommandTree
Commands.SystemFronter(var param, var flags) => ctx.Execute<SystemFront>(SystemFronter, m => m.Fronter(ctx, param.target)),
Commands.SystemFronterHistory(var param, var flags) => ctx.Execute<SystemFront>(SystemFrontHistory, m => m.FrontHistory(ctx, param.target, flags.clear)),
Commands.SystemFronterPercent(var param, var flags) => ctx.Execute<SystemFront>(SystemFrontPercent, m => m.FrontPercent(ctx, param.target, flags.duration, flags.fronters_only, flags.flat)),
Commands.RandomSelf(_, var flags) =>
flags.group
? ctx.Execute<Random>(GroupRandom, m => m.Group(ctx, ctx.System, flags.all, flags.show_embed))
: ctx.Execute<Random>(MemberRandom, m => m.Member(ctx, ctx.System, flags.all, flags.show_embed)),
Commands.SystemRandom(var param, var flags) =>
flags.group
? ctx.Execute<Random>(GroupRandom, m => m.Group(ctx, param.target, flags.all, flags.show_embed))
: ctx.Execute<Random>(MemberRandom, m => m.Member(ctx, param.target, flags.all, flags.show_embed)),
Commands.GroupRandomMember(var param, var flags) => ctx.Execute<Random>(GroupMemberRandom, m => m.GroupMember(ctx, param.target, flags.all, flags.show_embed)),
_ =>
// this should only ever occur when deving if commands are not implemented...
ctx.Reply(
@ -252,11 +261,6 @@ public partial class CommandTree
return HandleDebugCommand(ctx);
if (ctx.Match("admin"))
return HandleAdminCommand(ctx);
if (ctx.Match("random", "rand", "r"))
if (ctx.Match("group", "g") || ctx.MatchFlag("group", "g"))
return ctx.Execute<Random>(GroupRandom, r => r.Group(ctx, ctx.System));
else
return ctx.Execute<Random>(MemberRandom, m => m.Member(ctx, ctx.System));
if (ctx.Match("dashboard", "dash"))
return ctx.Execute<Help>(Dashboard, m => m.Dashboard(ctx));
}
@ -416,11 +420,6 @@ public partial class CommandTree
await ctx.CheckSystem(target).Execute<Groups>(GroupList, g => g.ListSystemGroups(ctx, target));
else if (ctx.Match("id"))
await ctx.CheckSystem(target).Execute<System>(SystemId, m => m.DisplayId(ctx, target));
else if (ctx.Match("random", "rand", "r"))
if (ctx.Match("group", "g") || ctx.MatchFlag("group", "g"))
await ctx.CheckSystem(target).Execute<Random>(GroupRandom, r => r.Group(ctx, target));
else
await ctx.CheckSystem(target).Execute<Random>(MemberRandom, m => m.Member(ctx, target));
}
private async Task HandleMemberCommand(Context ctx)

13
PluralKit.Bot/CommandSystem/Context/ContextEntityArgumentsExt.cs
View file

@ -147,13 +147,9 @@ public static class ContextEntityArgumentsExt
return member;
}
public static async Task<PKGroup> PeekGroup(this Context ctx, SystemId? restrictToSystem = null)
public static async Task<PKGroup> ParseGroup(this Context ctx, string input, bool byId, SystemId? restrictToSystem = null)
{
var input = ctx.PeekArgument();
// see PeekMember for an explanation of the logic used here
if (ctx.System != null && !ctx.MatchFlag("id", "by-id"))
if (ctx.System != null && !byId)
{
if (await ctx.Repository.GetGroupByName(ctx.System.Id, input) is { } byName)
return byName;
@ -170,6 +166,11 @@ public static class ContextEntityArgumentsExt
return null;
}
public static async Task<PKGroup> PeekGroup(this Context ctx, SystemId? restrictToSystem = null)
{
throw new NotImplementedException();
}
public static async Task<PKGroup> MatchGroup(this Context ctx, SystemId? restrictToSystem = null)
{
var group = await ctx.PeekGroup(restrictToSystem);

8
PluralKit.Bot/CommandSystem/Context/ContextParametersExt.cs
View file

@ -28,6 +28,14 @@ public static class ContextParametersExt
);
}
public static async Task<PKGroup?> ParamResolveGroup(this Context ctx, string param_name)
{
return await ctx.Parameters.ResolveParameter(
ctx, param_name,
param => (param as Parameter.GroupRef)?.group
);
}
public static async Task<PKSystem?> ParamResolveSystem(this Context ctx, string param_name)
{
return await ctx.Parameters.ResolveParameter(

6
PluralKit.Bot/CommandSystem/Parameters.cs
View file

@ -10,6 +10,7 @@ public abstract record Parameter()
{
public record MemberRef(PKMember member): Parameter;
public record MemberRefs(List<PKMember> members): Parameter;
public record GroupRef(PKGroup group): Parameter;
public record SystemRef(PKSystem system): Parameter;
public record GuildRef(Guild guild): Parameter;
public record MemberPrivacyTarget(MemberPrivacySubject target): Parameter;
@ -73,6 +74,11 @@ public class Parameters
?? throw new PKError(ctx.CreateNotFoundError("Member", m, byId))
).ToListAsync()
);
case uniffi.commands.Parameter.GroupRef groupRef:
return new Parameter.GroupRef(
await ctx.ParseGroup(groupRef.group, byId)
?? throw new PKError(ctx.CreateNotFoundError("Group", groupRef.group))
);
case uniffi.commands.Parameter.SystemRef systemRef:
// todo: do we need byId here?
return new Parameter.SystemRef(

12
PluralKit.Bot/Commands/Random.cs
View file

@ -15,7 +15,7 @@ public class Random
// todo: get postgresql to return one random member/group instead of querying all members/groups
public async Task Member(Context ctx, PKSystem target, bool showEmbed = false)
public async Task Member(Context ctx, PKSystem target, bool all, bool showEmbed = false)
{
if (target == null)
throw Errors.NoSystemError(ctx.DefaultPrefix);
@ -24,7 +24,7 @@ public class Random
var members = await ctx.Repository.GetSystemMembers(target.Id).ToListAsync();
if (!ctx.MatchFlag("all", "a"))
if (!all)
members = members.Where(m => m.MemberVisibility == PrivacyLevel.Public).ToList();
else
ctx.CheckOwnSystem(target);
@ -49,7 +49,7 @@ public class Random
components: await _embeds.CreateMemberMessageComponents(target, members[randInt], ctx.Guild, ctx.Config, ctx.LookupContextFor(target.Id), ctx.Zone));
}
public async Task Group(Context ctx, PKSystem target, bool showEmbed = false)
public async Task Group(Context ctx, PKSystem target, bool all, bool showEmbed = false)
{
if (target == null)
throw Errors.NoSystemError(ctx.DefaultPrefix);
@ -57,7 +57,7 @@ public class Random
ctx.CheckSystemPrivacy(target.Id, target.GroupListPrivacy);
var groups = await ctx.Repository.GetSystemGroups(target.Id).ToListAsync();
if (!ctx.MatchFlag("all", "a"))
if (!all)
groups = groups.Where(g => g.Visibility == PrivacyLevel.Public).ToList();
else
ctx.CheckOwnSystem(target);
@ -82,7 +82,7 @@ public class Random
components: await _embeds.CreateGroupMessageComponents(ctx, target, groups.ToArray()[randInt]));
}
public async Task GroupMember(Context ctx, PKGroup group, bool showEmbed = false)
public async Task GroupMember(Context ctx, PKGroup group, bool all, bool showEmbed = false)
{
ctx.CheckSystemPrivacy(group.System, group.ListPrivacy);
@ -96,7 +96,7 @@ public class Random
"This group has no members!"
+ (ctx.System?.Id == group.System ? " Please add at least one member to this group before using this command." : ""));
if (!ctx.MatchFlag("all", "a"))
if (!all)
members = members.Where(g => g.MemberVisibility == PrivacyLevel.Public);
else
ctx.CheckOwnGroup(group);

10
crates/command_definitions/src/group.rs
View file

@ -1 +1,11 @@
use command_parser::token::TokensIterator;
use super::*;
pub fn group() -> (&'static str, [&'static str; 1]) {
("group", ["g"])
}
pub fn targeted() -> TokensIterator {
tokens!(group(), GroupRef)
}

1
crates/command_definitions/src/lib.rs
View file

@ -27,6 +27,7 @@ pub fn all() -> impl Iterator<Item = Command> {
.chain(config::cmds())
.chain(fun::cmds())
.chain(switch::cmds())
.chain(random::cmds())
.map(|cmd| {
cmd.flag(("plaintext", ["pt"]))
.flag(("raw", ["r"]))

13
crates/command_definitions/src/random.rs
View file

@ -1 +1,14 @@
use super::*;
pub fn cmds() -> impl Iterator<Item = Command> {
let random = ("random", ["rand"]);
let group = group::group();
[
command!(random => "random_self").flag(group),
command!(system::targeted(), random => "system_random").flag(group),
command!(group::targeted(), random => "group_random_member"),
]
.into_iter()
.map(|cmd| cmd.flag(("all", ["a"])))
}

14
crates/command_definitions/src/system.rs
View file

@ -1,12 +1,22 @@
use command_parser::token::TokensIterator;
use super::*;
pub fn cmds() -> impl Iterator<Item = Command> {
edit()
}
pub fn system() -> (&'static str, [&'static str; 1]) {
("system", ["s"])
}
pub fn targeted() -> TokensIterator {
tokens!(system(), SystemRef)
}
pub fn edit() -> impl Iterator<Item = Command> {
let system = ("system", ["s"]);
let system_target = tokens!(system, SystemRef);
let system = system();
let system_target = targeted();
let system_new = tokens!(system, ("new", ["n"]));
let system_new_cmd = [

5
crates/command_parser/src/parameter.rs
View file

@ -12,6 +12,7 @@ pub enum ParameterValue {
OpaqueString(String),
MemberRef(String),
MemberRefs(Vec<String>),
GroupRef(String),
SystemRef(String),
GuildRef(String),
MemberPrivacyTarget(String),
@ -48,6 +49,7 @@ impl Display for Parameter {
}
ParameterKind::MemberRef => write!(f, "<target member>"),
ParameterKind::MemberRefs => write!(f, "<member 1> <member 2> <member 3>..."),
ParameterKind::GroupRef => write!(f, "<target group>"),
ParameterKind::SystemRef => write!(f, "<target system>"),
ParameterKind::GuildRef => write!(f, "<target guild>"),
ParameterKind::MemberPrivacyTarget => write!(f, "<privacy target>"),
@ -83,6 +85,7 @@ pub enum ParameterKind {
OpaqueStringRemainder,
MemberRef,
MemberRefs,
GroupRef,
SystemRef,
GuildRef,
MemberPrivacyTarget,
@ -99,6 +102,7 @@ impl ParameterKind {
ParameterKind::OpaqueStringRemainder => "string",
ParameterKind::MemberRef => "target",
ParameterKind::MemberRefs => "targets",
ParameterKind::GroupRef => "target",
ParameterKind::SystemRef => "target",
ParameterKind::GuildRef => "target",
ParameterKind::MemberPrivacyTarget => "member_privacy_target",
@ -122,6 +126,7 @@ impl ParameterKind {
ParameterKind::OpaqueString | ParameterKind::OpaqueStringRemainder => {
Ok(ParameterValue::OpaqueString(input.into()))
}
ParameterKind::GroupRef => Ok(ParameterValue::GroupRef(input.into())),
ParameterKind::MemberRef => Ok(ParameterValue::MemberRef(input.into())),
ParameterKind::MemberRefs => Ok(ParameterValue::MemberRefs(
input.split(' ').map(|s| s.trim().to_string()).collect(),

2
crates/commands/src/bin/write_cs_glue.rs
View file

@ -168,6 +168,7 @@ fn get_param_ty(kind: ParameterKind) -> &'static str {
ParameterKind::OpaqueString | ParameterKind::OpaqueStringRemainder => "string",
ParameterKind::MemberRef => "PKMember",
ParameterKind::MemberRefs => "List<PKMember>",
ParameterKind::GroupRef => "PKGroup",
ParameterKind::SystemRef => "PKSystem",
ParameterKind::MemberPrivacyTarget => "MemberPrivacySubject",
ParameterKind::SystemPrivacyTarget => "SystemPrivacySubject",
@ -183,6 +184,7 @@ fn get_param_param_ty(kind: ParameterKind) -> &'static str {
ParameterKind::OpaqueString | ParameterKind::OpaqueStringRemainder => "Opaque",
ParameterKind::MemberRef => "Member",
ParameterKind::MemberRefs => "Members",
ParameterKind::GroupRef => "Group",
ParameterKind::SystemRef => "System",
ParameterKind::MemberPrivacyTarget => "MemberPrivacyTarget",
ParameterKind::SystemPrivacyTarget => "SystemPrivacyTarget",

1
crates/commands/src/commands.udl
View file

@ -10,6 +10,7 @@ interface CommandResult {
interface Parameter {
MemberRef(string member);
MemberRefs(sequence<string> members);
GroupRef(string group);
SystemRef(string system);
GuildRef(string guild);
MemberPrivacyTarget(string target);

2
crates/commands/src/lib.rs
View file

@ -24,6 +24,7 @@ pub enum CommandResult {
pub enum Parameter {
MemberRef { member: String },
MemberRefs { members: Vec<String> },
GroupRef { group: String },
SystemRef { system: String },
GuildRef { guild: String },
MemberPrivacyTarget { target: String },
@ -39,6 +40,7 @@ impl From<ParameterValue> for Parameter {
match value {
ParameterValue::MemberRef(member) => Self::MemberRef { member },
ParameterValue::MemberRefs(members) => Self::MemberRefs { members },
ParameterValue::GroupRef(group) => Self::GroupRef { group },
ParameterValue::SystemRef(system) => Self::SystemRef { system },
ParameterValue::MemberPrivacyTarget(target) => Self::MemberPrivacyTarget { target },
ParameterValue::SystemPrivacyTarget(target) => Self::SystemPrivacyTarget { target },