Example #1
0
    public static JObject ToJson(this MemberGuildSettings settings)
    {
        var o = new JObject();

        o.Add("display_name", settings.DisplayName);
        o.Add("avatar_url", settings.AvatarUrl);

        return(o);
    }
Example #2
0
        private async Task <EmbedBuilder> CreateMemberNameInfoEmbed(Context ctx, PKMember target)
        {
            var lcx = ctx.LookupContextFor(target);

            MemberGuildSettings memberGuildConfig = null;

            if (ctx.Guild != null)
            {
                memberGuildConfig = await _db.Execute(c => _repo.GetMemberGuild(c, ctx.Guild.Id, target.Id));
            }

            var eb = new EmbedBuilder()
                     .Title($"Member names")
                     .Footer(new($"Member ID: {target.Hid} | Active name in bold. Server name overrides display name, which overrides base name."));

            if (target.DisplayName == null && memberGuildConfig?.DisplayName == null)
            {
                eb.Field(new("Name", $"**{target.NameFor(ctx)}**"));
            }
            else
            {
                eb.Field(new("Name", target.NameFor(ctx)));
            }

            if (target.NamePrivacy.CanAccess(lcx))
            {
                if (target.DisplayName != null && memberGuildConfig?.DisplayName == null)
                {
                    eb.Field(new("Display Name", $"**{target.DisplayName}**"));
                }
                else
                {
                    eb.Field(new("Display Name", target.DisplayName ?? "*(none)*"));
                }
            }

            if (ctx.Guild != null)
            {
                if (memberGuildConfig?.DisplayName != null)
                {
                    eb.Field(new($"Server Name (in {ctx.Guild.Name})", $"**{memberGuildConfig.DisplayName}**"));
                }
                else
                {
                    eb.Field(new($"Server Name (in {ctx.Guild.Name})", memberGuildConfig?.DisplayName ?? "*(none)*"));
                }
            }

            return(eb);
        }
Example #3
0
        private async Task <DiscordEmbedBuilder> CreateMemberNameInfoEmbed(Context ctx, PKMember target)
        {
            MemberGuildSettings memberGuildConfig = null;

            if (ctx.Guild != null)
            {
                memberGuildConfig = await _db.Execute(c => c.QueryOrInsertMemberGuildConfig(ctx.Guild.Id, target.Id));
            }

            var eb = new DiscordEmbedBuilder().WithTitle($"Member names")
                     .WithFooter($"Member ID: {target.Hid} | Active name in bold. Server name overrides display name, which overrides base name.");

            if (target.DisplayName == null && memberGuildConfig?.DisplayName == null)
            {
                eb.AddField($"Name", $"**{target.Name}**");
            }
            else
            {
                eb.AddField("Name", target.Name);
            }

            if (target.DisplayName != null && memberGuildConfig?.DisplayName == null)
            {
                eb.AddField($"Display Name", $"**{target.DisplayName}**");
            }
            else
            {
                eb.AddField("Display Name", target.DisplayName ?? "*(none)*");
            }

            if (ctx.Guild != null)
            {
                if (memberGuildConfig?.DisplayName != null)
                {
                    eb.AddField($"Server Name (in {ctx.Guild.Name.SanitizeMentions()})", $"**{memberGuildConfig.DisplayName}**");
                }
                else
                {
                    eb.AddField($"Server Name (in {ctx.Guild.Name.SanitizeMentions()})", memberGuildConfig?.DisplayName ?? "*(none)*");
                }
            }

            return(eb);
        }
Example #4
0
        public async Task Privacy(Context ctx, PKMember target, PrivacyLevel?newValueFromCommand)
        {
            ctx.CheckSystem().CheckOwnMember(target);

            // Display privacy settings
            if (!ctx.HasNext() && newValueFromCommand == null)
            {
                await ctx.Reply(embed : new EmbedBuilder()
                                .Title($"Current privacy settings for {target.NameFor(ctx)}")
                                .Field(new("Name (replaces name with display name if member has one)", target.NamePrivacy.Explanation()))
                                .Field(new("Description", target.DescriptionPrivacy.Explanation()))
                                .Field(new("Avatar", target.AvatarPrivacy.Explanation()))
                                .Field(new("Birthday", target.BirthdayPrivacy.Explanation()))
                                .Field(new("Pronouns", target.PronounPrivacy.Explanation()))
                                .Field(new("Meta (message count, last front, last message)", target.MetadataPrivacy.Explanation()))
                                .Field(new("Visibility", target.MemberVisibility.Explanation()))
                                .Description("To edit privacy settings, use the command:\n`pk;member <member> privacy <subject> <level>`\n\n- `subject` is one of `name`, `description`, `avatar`, `birthday`, `pronouns`, `created`, `messages`, `visibility`, or `all`\n- `level` is either `public` or `private`.")
                                .Build());

                return;
            }

            // Get guild settings (mostly for warnings and such)
            MemberGuildSettings guildSettings = null;

            if (ctx.Guild != null)
            {
                guildSettings = await _db.Execute(c => _repo.GetMemberGuild(c, ctx.Guild.Id, target.Id));
            }

            async Task SetAll(PrivacyLevel level)
            {
                await _db.Execute(c => _repo.UpdateMember(c, target.Id, new MemberPatch().WithAllPrivacy(level)));

                if (level == PrivacyLevel.Private)
                {
                    await ctx.Reply($"{Emojis.Success} All {target.NameFor(ctx)}'s privacy settings have been set to **{level.LevelName()}**. Other accounts will now see nothing on the member card.");
                }
                else
                {
                    await ctx.Reply($"{Emojis.Success} All {target.NameFor(ctx)}'s privacy settings have been set to **{level.LevelName()}**. Other accounts will now see everything on the member card.");
                }
            }

            async Task SetLevel(MemberPrivacySubject subject, PrivacyLevel level)
            {
                await _db.Execute(c => _repo.UpdateMember(c, target.Id, new MemberPatch().WithPrivacy(subject, level)));

                var subjectName = subject switch
                {
                    MemberPrivacySubject.Name => "name privacy",
                    MemberPrivacySubject.Description => "description privacy",
                    MemberPrivacySubject.Avatar => "avatar privacy",
                    MemberPrivacySubject.Pronouns => "pronoun privacy",
                    MemberPrivacySubject.Birthday => "birthday privacy",
                    MemberPrivacySubject.Metadata => "metadata privacy",
                    MemberPrivacySubject.Visibility => "visibility",
                    _ => throw new ArgumentOutOfRangeException($"Unknown privacy subject {subject}")
                };

                var explanation = (subject, level) switch
                {
                    (MemberPrivacySubject.Name, PrivacyLevel.Private) => "This member's name is now hidden from other systems, and will be replaced by the member's display name.",
                    (MemberPrivacySubject.Description, PrivacyLevel.Private) => "This member's description is now hidden from other systems.",
                    (MemberPrivacySubject.Avatar, PrivacyLevel.Private) => "This member's avatar is now hidden from other systems.",
                    (MemberPrivacySubject.Birthday, PrivacyLevel.Private) => "This member's birthday is now hidden from other systems.",
                    (MemberPrivacySubject.Pronouns, PrivacyLevel.Private) => "This member's pronouns are now hidden from other systems.",
                    (MemberPrivacySubject.Metadata, PrivacyLevel.Private) => "This member's metadata (eg. created timestamp, message count, etc) is now hidden from other systems.",
                    (MemberPrivacySubject.Visibility, PrivacyLevel.Private) => "This member is now hidden from member lists.",

                    (MemberPrivacySubject.Name, PrivacyLevel.Public) => "This member's name is no longer hidden from other systems.",
                    (MemberPrivacySubject.Description, PrivacyLevel.Public) => "This member's description is no longer hidden from other systems.",
                    (MemberPrivacySubject.Avatar, PrivacyLevel.Public) => "This member's avatar is no longer hidden from other systems.",
                    (MemberPrivacySubject.Birthday, PrivacyLevel.Public) => "This member's birthday is no longer hidden from other systems.",
                    (MemberPrivacySubject.Pronouns, PrivacyLevel.Public) => "This member's pronouns are no longer hidden other systems.",
                    (MemberPrivacySubject.Metadata, PrivacyLevel.Public) => "This member's metadata (eg. created timestamp, message count, etc) is no longer hidden from other systems.",
                    (MemberPrivacySubject.Visibility, PrivacyLevel.Public) => "This member is no longer hidden from member lists.",

                    _ => throw new InvalidOperationException($"Invalid subject/level tuple ({subject}, {level})")
                };

                await ctx.Reply($"{Emojis.Success} {target.NameFor(ctx)}'s **{subjectName}** has been set to **{level.LevelName()}**. {explanation}");

                // Name privacy only works given a display name
                if (subject == MemberPrivacySubject.Name && level == PrivacyLevel.Private && target.DisplayName == null)
                {
                    await ctx.Reply($"{Emojis.Warn} This member does not have a display name set, and name privacy **will not take effect**.");
                }

                // Avatar privacy doesn't apply when proxying if no server avatar is set
                if (subject == MemberPrivacySubject.Avatar && level == PrivacyLevel.Private && guildSettings?.AvatarUrl == null)
                {
                    await ctx.Reply($"{Emojis.Warn} This member does not have a server avatar set, so *proxying* will **still show the member avatar**. If you want to hide your avatar when proxying here, set a server avatar: `pk;member {target.Reference()} serveravatar`");
                }
            }

            if (ctx.Match("all") || newValueFromCommand != null)
            {
                await SetAll(newValueFromCommand ?? ctx.PopPrivacyLevel());
            }
            else
            {
                await SetLevel(ctx.PopMemberPrivacySubject(), ctx.PopPrivacyLevel());
            }
        }
Example #5
0
        public async Task ServerName(Context ctx, PKMember target)
        {
            ctx.CheckGuildContext();

            if (await ctx.MatchClear("this member's server name"))
            {
                ctx.CheckOwnMember(target);

                var patch = new MemberGuildPatch {
                    DisplayName = null
                };
                await _db.Execute(conn => _repo.UpsertMemberGuild(conn, target.Id, ctx.Guild.Id, patch));

                if (target.DisplayName != null)
                {
                    await ctx.Reply($"{Emojis.Success} Member server name cleared. This member will now be proxied using their global display name \"{target.DisplayName}\" in this server ({ctx.Guild.Name}).");
                }
                else
                {
                    await ctx.Reply($"{Emojis.Success} Member server name cleared. This member will now be proxied using their member name \"{target.NameFor(ctx)}\" in this server ({ctx.Guild.Name}).");
                }
            }
            else if (!ctx.HasNext())
            {
                // No perms check, display name isn't covered by member privacy
                if (ctx.MatchFlag("r", "raw"))
                {
                    MemberGuildSettings memberGuildConfig = await _db.Execute(c => _repo.GetMemberGuild(c, ctx.Guild.Id, target.Id));

                    if (memberGuildConfig.DisplayName == null)
                    {
                        if (ctx.System?.Id == target.System)
                        {
                            await ctx.Reply($"This member does not have a server name set. To set one, type `pk;member {target.Reference()} servername <server name>`.");
                        }
                        else
                        {
                            await ctx.Reply("This member does not have a server name set.");
                        }
                    }
                    else
                    {
                        await ctx.Reply($"```\n{memberGuildConfig.DisplayName}\n```");
                    }
                }
                else
                {
                    var eb = await CreateMemberNameInfoEmbed(ctx, target);

                    if (ctx.System?.Id == target.System)
                    {
                        eb.Description($"To change server name, type `pk;member {target.Reference()} servername <server name>`.\nTo clear it, type `pk;member {target.Reference()} servername -clear`.\nTo print the raw server name, type `pk;member {target.Reference()} servername -raw`.");
                    }
                    await ctx.Reply(embed : eb.Build());
                }
            }
            else
            {
                ctx.CheckOwnMember(target);

                var newServerName = ctx.RemainderOrNull();

                var patch = new MemberGuildPatch {
                    DisplayName = newServerName
                };
                await _db.Execute(conn => _repo.UpsertMemberGuild(conn, target.Id, ctx.Guild.Id, patch));

                await ctx.Reply($"{Emojis.Success} Member server name changed. This member will now be proxied using the name \"{newServerName}\" in this server ({ctx.Guild.Name}).");
            }
        }
Example #6
0
        public async Task Privacy(Context ctx, PKMember target, PrivacyLevel?newValueFromCommand)
        {
            if (ctx.System == null)
            {
                throw Errors.NoSystemError;
            }
            if (target.System != ctx.System.Id)
            {
                throw Errors.NotOwnMemberError;
            }

            // Display privacy settings
            if (!ctx.HasNext() && newValueFromCommand == null)
            {
                await ctx.Reply(embed : CreatePrivacyEmbed(ctx, target));

                return;
            }

            // Get guild settings (mostly for warnings and such)
            MemberGuildSettings guildSettings = null;

            if (ctx.Guild != null)
            {
                guildSettings = await _db.Execute(c => c.QueryOrInsertMemberGuildConfig(ctx.Guild.Id, target.Id));
            }

            // Set Privacy Settings
            PrivacyLevel PopPrivacyLevel(string subjectName)
            {
                if (ctx.Match("public", "show", "shown", "visible"))
                {
                    return(PrivacyLevel.Public);
                }

                if (ctx.Match("private", "hide", "hidden"))
                {
                    return(PrivacyLevel.Private);
                }

                if (!ctx.HasNext())
                {
                    throw new PKSyntaxError($"You must pass a privacy level for `{subjectName}` (`public` or `private`)");
                }
                throw new PKSyntaxError($"Invalid privacy level `{ctx.PopArgument()}` (must be `public` or `private`).");
            }

            // See if we have a subject given
            PrivacyLevel newLevel;

            if (PrivacyUtils.TryParseMemberPrivacy(ctx.PeekArgument(), out var subject))
            {
                // We peeked before, pop it now
                ctx.PopArgument();

                // Read the privacy level from args
                newLevel = PopPrivacyLevel(subject.Name());

                // Set the level on the given subject
                target.SetPrivacy(subject, newLevel);
                await _data.SaveMember(target);

                // Print response
                var explanation = (subject, newLevel) switch
                {
                    (MemberPrivacySubject.Name, PrivacyLevel.Private) => "This member's name is now hidden from other systems, and will be replaced by the member's display name.",
                    (MemberPrivacySubject.Description, PrivacyLevel.Private) => "This member's description is now hidden from other systems.",
                    (MemberPrivacySubject.Avatar, PrivacyLevel.Private) => "This member's avatar is now hidden from other systems.",
                    (MemberPrivacySubject.Birthday, PrivacyLevel.Private) => "This member's birthday is now hidden from other systems.",
                    (MemberPrivacySubject.Pronouns, PrivacyLevel.Private) => "This member's pronouns are now hidden from other systems.",
                    (MemberPrivacySubject.Metadata, PrivacyLevel.Private) => "This member's metadata (eg. created timestamp, message count, etc) is now hidden from other systems.",
                    (MemberPrivacySubject.Visibility, PrivacyLevel.Private) => "This member is now hidden from member lists.",

                    (MemberPrivacySubject.Name, PrivacyLevel.Public) => "This member's name is no longer hidden from other systems.",
                    (MemberPrivacySubject.Description, PrivacyLevel.Public) => "This member's description is no longer hidden from other systems.",
                    (MemberPrivacySubject.Avatar, PrivacyLevel.Public) => "This member's avatar is no longer hidden from other systems.",
                    (MemberPrivacySubject.Birthday, PrivacyLevel.Public) => "This member's birthday is no longer hidden from other systems.",
                    (MemberPrivacySubject.Pronouns, PrivacyLevel.Public) => "This member's pronouns are no longer hidden other systems.",
                    (MemberPrivacySubject.Metadata, PrivacyLevel.Public) => "This member's metadata (eg. created timestamp, message count, etc) is no longer hidden from other systems.",
                    (MemberPrivacySubject.Visibility, PrivacyLevel.Public) => "This member is no longer hidden from member lists.",

                    _ => throw new InvalidOperationException($"Invalid subject/level tuple ({subject}, {newLevel})")
                };

                await ctx.Reply($"{Emojis.Success} {target.NameFor(ctx)}'s {subject.Name()} has been set to **{newLevel.LevelName()}**. {explanation}");
            }
            else if (ctx.Match("all") || newValueFromCommand != null)
            {
                newLevel = newValueFromCommand ?? PopPrivacyLevel("all");
                target.SetAllPrivacy(newLevel);
                await _data.SaveMember(target);

                if (newLevel == PrivacyLevel.Private)
                {
                    await ctx.Reply($"All {target.NameFor(ctx)}'s privacy settings have been set to **{newLevel.LevelName()}**. Other accounts will now see nothing on the member card.");
                }
                else
                {
                    await ctx.Reply($"All {target.NameFor(ctx)}'s privacy settings have been set to **{newLevel.LevelName()}**. Other accounts will now see everything on the member card.");
                }
            }
            else
            {
                var subjectList = "`name`, `description`, `avatar`, `birthday`, `pronouns`, `metadata`, `visibility`, or `all`";
                throw new PKSyntaxError($"Invalid privacy subject `{ctx.PopArgument()}` (must be {subjectList}).");
            }

            // Name privacy only works given a display name
            if (subject == MemberPrivacySubject.Name && newLevel == PrivacyLevel.Private && target.DisplayName == null)
            {
                await ctx.Reply($"{Emojis.Warn} This member does not have a display name set, and name privacy **will not take effect**.");
            }
            // Avatar privacy doesn't apply when proxying if no server avatar is set
            if (subject == MemberPrivacySubject.Avatar && newLevel == PrivacyLevel.Private &&
                guildSettings?.AvatarUrl == null)
            {
                await ctx.Reply($"{Emojis.Warn} This member does not have a server avatar set, so *proxying* will **still show the member avatar**. If you want to hide your avatar when proxying here, set a server avatar: `pk;member {target.Hid} serveravatar`");
            }
        }