Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
9.0 KB
Raw Blame
%% SPDX-License-Identifier: AGPL-3.0-or-later

-module(guild_thread_push).
-typing([eqwalizer]).

-export([
    scope/2,
    is_candidate/4,
    role_visible/2,
    role_adds/4,
    push_message_data/4,
    forum_starter/3,
    mark_forum_thread_created/1,
    mention_universe/2,
    passive_threads/3
]).

-export_type([scope/0]).

-define(THREAD_PUSH_KEY, <<"__thread_push">>).
-define(FORUM_THREAD_CREATED_KEY, <<"__forum_thread_created">>).
-define(MEMBER_SETTING_KEYS, [<<"flags">>, <<"muted">>, <<"mute_config">>]).

-define(MAX_ROLE_MENTION_THREAD_ADDS, 250).
-define(MAX_THREAD_MEMBERS, 1000).

-type user_id() :: integer().
-type member_source() :: {ets, ets:tid()} | {map, map()}.

-type scope() :: #{thread := map(), members := #{integer() => map()}} | undefined.

-spec scope(integer(), map()) -> scope().
scope(ChannelId, State) ->
    case guild_thread_gate:store(State) of
        undefined -> undefined;
        Tab -> safe_scope(Tab, ChannelId)
    end.

-spec safe_scope(ets:table(), integer()) -> scope().
safe_scope(Tab, ChannelId) ->
    try guild_thread_store:get_thread(Tab, ChannelId) of
        undefined ->
            undefined;
        Thread ->
            #{
                thread => Thread,
                members => maps:from_list(guild_thread_store:members(Tab, ChannelId))
            }
    catch
        error:badarg -> undefined
    end.

-spec push_message_data(map(), integer(), [integer()], map()) -> {map(), binary()} | undefined.
push_message_data(MessageData, ChannelId, UserIds, Data) ->
    case scope(ChannelId, Data) of
        undefined ->
            undefined;
        #{thread := Thread, members := Members} ->
            ParentId = snowflake_id:parse_optional(
                maps:get(<<"parent_id">>, Thread, undefined)
            ),
            Parent = parent_channel(ParentId, Data),
            {ForumFields, MessageData1} = take_forum_thread_created(MessageData),
            ThreadPush = ForumFields#{
                <<"parent_id">> => ParentId,
                <<"parent_name">> => binary_or_undefined(
                    maps:get(<<"name">>, Parent, undefined)
                ),
                <<"category_id">> => snowflake_id:parse_optional(
                    maps:get(<<"parent_id">>, Parent, undefined)
                ),
                <<"members">> => member_settings(UserIds, Members)
            },
            {
                MessageData1#{?THREAD_PUSH_KEY => ThreadPush},
                thread_name(Thread)
            }
    end.

-spec take_forum_thread_created(map()) -> {#{binary() => true}, map()}.
take_forum_thread_created(MessageData) ->
    case maps:take(?FORUM_THREAD_CREATED_KEY, MessageData) of
        {true, Rest} -> {#{<<"forum_thread_created">> => true}, Rest};
        {_Other, Rest} -> {#{}, Rest};
        error -> {#{}, MessageData}
    end.

-spec mark_forum_thread_created(map()) -> map().
mark_forum_thread_created(MessageData) ->
    MessageData#{?FORUM_THREAD_CREATED_KEY => true}.

-spec forum_starter(map(), integer(), map()) -> {integer(), #{integer() => map()}} | undefined.
forum_starter(MessageData, ChannelId, Data) ->
    case snowflake_id:parse_maybe(maps:get(<<"id">>, MessageData, undefined)) of
        ChannelId -> forum_starter_scope(scope(ChannelId, Data), Data);
        _ -> undefined
    end.

-spec forum_starter_scope(scope(), map()) -> {integer(), #{integer() => map()}} | undefined.
forum_starter_scope(#{thread := Thread, members := Members}, Data) ->
    ParentId = snowflake_id:parse_maybe(maps:get(<<"parent_id">>, Thread, undefined)),
    case
        channel_types:is_thread_only(
            maps:get(<<"type">>, parent_channel(ParentId, Data), undefined)
        )
    of
        true when is_integer(ParentId) -> {ParentId, Members};
        _ -> undefined
    end;
forum_starter_scope(undefined, _Data) ->
    undefined.

-spec parent_channel(integer() | undefined, map()) -> map().
parent_channel(ParentId, Data) when is_integer(ParentId) ->
    case maps:get(ParentId, guild_data_index_channels:channel_index(Data), undefined) of
        Parent when is_map(Parent) -> Parent;
        _ -> #{}
    end;
parent_channel(_ParentId, _Data) ->
    #{}.

-spec member_settings([integer()], #{integer() => map()}) -> #{integer() => map()}.
member_settings(UserIds, Members) ->
    maps:map(
        fun(_UserId, Member) -> maps:with(?MEMBER_SETTING_KEYS, Member) end,
        maps:with(UserIds, Members)
    ).

-spec thread_name(map()) -> binary().
thread_name(Thread) ->
    case binary_or_undefined(maps:get(<<"name">>, Thread, undefined)) of
        undefined -> <<"unknown">>;
        Name -> Name
    end.

-spec binary_or_undefined(term()) -> binary() | undefined.
binary_or_undefined(Value) when is_binary(Value), byte_size(Value) > 0 -> Value;
binary_or_undefined(_Value) -> undefined.

-spec mention_universe(integer(), map()) -> #{integer() => true} | undefined.
mention_universe(ChannelId, State) ->
    case scope(ChannelId, State) of
        undefined ->
            undefined;
        #{members := Members} ->
            Recipient = guild_thread_gate:recipient_active(ChannelId, State),
            maps:from_keys([UserId || UserId <- maps:keys(Members), Recipient(UserId)], true)
    end.

-spec passive_threads(map(), integer(), map()) -> [map()].
passive_threads(SessionData, UserId, State) ->
    case {guild_thread_gate:session_viewer(SessionData), guild_thread_gate:store(State)} of
        {true, Tab} when Tab =/= undefined -> joined_threads(Tab, UserId);
        _ -> []
    end.

-spec joined_threads(ets:table(), integer()) -> [map()].
joined_threads(Tab, UserId) ->
    try
        [
            Thread
         || ThreadId <- guild_thread_store:user_thread_ids(Tab, UserId),
            Thread <- [guild_thread_store:get_thread(Tab, ThreadId)],
            is_map(Thread)
        ]
    catch
        error:badarg -> []
    end.

-spec is_candidate(integer(), map(), scope(), map()) -> boolean().
is_candidate(_UserId, _Member, undefined, _Mentions) ->
    true;
is_candidate(UserId, _Member, #{members := Members}, Mentions) ->
    maps:is_key(UserId, Members) orelse
        maps:is_key(UserId, maps:get(direct_mentions, Mentions)) orelse
        maps:is_key(UserId, maps:get(role_adds, Mentions)).

-spec role_visible(integer(), map()) -> fun((integer(), map()) -> boolean()).
role_visible(ChannelId, State) ->
    Recipient = guild_thread_gate:recipient_active(ChannelId, State),
    fun(UserId, Member) ->
        Recipient(UserId) andalso
            guild_permissions_check:can_view_channel(UserId, ChannelId, Member, State)
    end.

-type role_add_request() :: #{
    members := map(),
    mentions := map(),
    mention_roles := map(),
    source := member_source(),
    visible := fun((user_id(), map()) -> boolean())
}.

-spec role_adds(
    map(), map(), {ets, ets:tid()} | {map, map()}, fun((integer(), map()) -> boolean())
) -> #{integer() => true}.
role_adds(#{thread := Thread, members := Members}, Mentions, Source, Visible) ->
    MentionRoles = maps:get(mention_roles, Mentions),
    case map_size(MentionRoles) of
        0 ->
            #{};
        _ ->
            select_role_adds(Thread, #{
                members => Members,
                mentions => Mentions,
                mention_roles => MentionRoles,
                source => Source,
                visible => Visible
            })
    end.

-spec select_role_adds(map(), role_add_request()) -> #{user_id() => true}.
select_role_adds(#{<<"type">> := 12}, _Request) ->
    #{};
select_role_adds(#{<<"thread_metadata">> := #{<<"archived">> := true}}, _Request) ->
    #{};
select_role_adds(_Thread, #{
    members := Members,
    mentions := Mentions,
    mention_roles := MentionRoles,
    source := Source,
    visible := Visible
}) ->
    Direct = maps:get(direct_mentions, Mentions),
    AuthorId = maps:get(author_id, Mentions),
    Candidates = guild_push_candidates:filtermap_members(
        fun(UserId, Member) ->
            UserId =/= AuthorId andalso
                not maps:is_key(UserId, Members) andalso
                not maps:is_key(UserId, Direct) andalso
                guild_push_candidates:has_mentioned_role(Member, MentionRoles) andalso
                not guild_members_common:is_member_bot(Member) andalso
                {true, UserId}
        end,
        Source
    ),
    Room = max(0, ?MAX_THREAD_MEMBERS - map_size(Members)),
    take_role_adds(
        lists:sort(Candidates),
        Source,
        Visible,
        min(?MAX_ROLE_MENTION_THREAD_ADDS, Room),
        #{}
    ).

-spec take_role_adds(
    [user_id()],
    member_source(),
    fun((user_id(), map()) -> boolean()),
    non_neg_integer(),
    map()
) -> #{user_id() => true}.
take_role_adds([], _Source, _Visible, _Left, Acc) ->
    Acc;
take_role_adds(_UserIds, _Source, _Visible, 0, Acc) ->
    Acc;
take_role_adds([UserId | Rest], Source, Visible, Left, Acc) ->
    Member = guild_push_candidates:lookup_member(UserId, Source),
    case is_map(Member) andalso Visible(UserId, Member) of
        true -> take_role_adds(Rest, Source, Visible, Left - 1, Acc#{UserId => true});
        false -> take_role_adds(Rest, Source, Visible, Left, Acc)
    end.