Skip to content

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

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

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

-export([get_guild_data/2]).
-export([get_auth_context/2]).

-export([get_first_viewable_text_channel/1]).
-export([get_guild_state/2, get_guild_state/3]).
-export([build_connect_snapshot/2]).
-export([fetch_latest_voice_states/1]).

-type guild_state() :: map().
-type guild_reply(T) :: {reply, T, guild_state()}.
-type user_id() :: integer().
-type guild_id() :: integer().

-define(CONNECT_SNAPSHOT_HEAVY_MEMBER_KEYS, [
    <<"members">>,
    members_normalized,
    <<"member_role_index">>,
    members_sorted_ids,
    member_list_revision
]).
-define(CONNECT_SNAPSHOT_HEAVY_SESSION_KEYS, [active_guilds, user_roles, viewable_channels]).

-export_type([guild_state/0]).

-spec get_guild_data(map(), guild_state()) -> {reply, map(), guild_state()}.
get_guild_data(#{user_id := UserId}, State) ->
    Data = guild_data_index:ensure_data_map(State),
    case UserId of
        null ->
            GuildData = build_complete_guild_data(Data, State),
            {reply, #{guild_data => GuildData}, State};
        _ ->
            get_guild_data_for_user(UserId, Data, State)
    end.

-spec get_auth_context(map(), guild_state()) -> {reply, map(), guild_state()}.
get_auth_context(#{user_id := UserId, channel_id := ChannelId}, State) ->
    Data = guild_data_index:ensure_data_map(State),
    case UserId of
        null ->
            {reply, #{auth_context => build_auth_context(ChannelId, Data, State)}, State};
        _ ->
            get_auth_context_for_member(UserId, ChannelId, Data, State)
    end.

-spec get_auth_context_for_member(user_id(), integer() | null, map(), guild_state()) ->
    guild_reply(map()).
get_auth_context_for_member(UserId, ChannelId, Data, State) ->
    case guild_data_index_members:get_member(UserId, Data) of
        undefined ->
            {reply, #{auth_context => null, error_reason => <<"forbidden">>}, State};
        _Member ->
            {reply, #{auth_context => build_auth_context(ChannelId, Data, State)}, State}
    end.

-spec build_auth_context(integer() | null, map(), guild_state()) -> map().
build_auth_context(ChannelId, Data, State) ->
    #{
        <<"guild">> => build_auth_guild(Data, State),
        <<"parent_channel">> => find_channel(ChannelId, Data)
    }.

-spec build_auth_guild(map(), guild_state()) -> map().
build_auth_guild(Data, State) ->
    GuildProperties = map_utils:ensure_map(maps:get(<<"guild">>, Data, #{})),
    GuildProperties#{
        <<"roles">> => map_utils:ensure_list(maps:get(<<"roles">>, Data, [])),
        <<"member_count">> => maps:get(
            member_count, State, guild_data_index_members:member_count(Data)
        ),
        <<"online_count">> => guild_member_list_read:get_online_count(State)
    }.

-spec find_channel(integer() | null, map()) -> map() | null.
find_channel(null, _Data) ->
    null;
find_channel(ChannelId, Data) ->
    Index = guild_data_index_channels:channel_index(Data),
    case maps:get(ChannelId, Index, null) of
        null -> find_thread_parent_channel(ChannelId, Index, Data);
        Channel -> Channel
    end.

-spec find_thread_parent_channel(term(), map(), map()) -> map() | null.
find_thread_parent_channel(ChannelId, Index, Data) when is_integer(ChannelId) ->
    case guild_thread_gate:thread(ChannelId, Data) of
        undefined ->
            null;
        Thread ->
            maps:get(guild_thread_permissions:parent_id(Thread), Index, null)
    end;
find_thread_parent_channel(_ChannelId, _Index, _Data) ->
    null.

-spec get_first_viewable_text_channel(guild_state()) -> {reply, map(), guild_state()}.
get_first_viewable_text_channel(State) ->
    get_everyone_viewable_text_channel(State).

-spec get_everyone_viewable_text_channel(guild_state()) -> guild_reply(map()).
get_everyone_viewable_text_channel(State) ->
    Channels = guild_data_channels:channels_from_state(State),
    EveryoneChannelId = guild_data_channels:find_everyone_viewable_text_channel(
        Channels, State
    ),
    {reply, #{channel_id => EveryoneChannelId}, State}.

-spec get_guild_state(integer(), guild_state()) -> map().
get_guild_state(UserId, State) ->
    get_guild_state(UserId, State, #{}).

-spec get_guild_state(integer(), guild_state(), map()) -> map().
get_guild_state(UserId, State, Opts) ->
    GuildState = base_guild_state(UserId, State),
    case guild_thread_gate:needs_variant(State) of
        false -> GuildState;
        true -> apply_thread_view(UserId, Opts, State, GuildState)
    end.

-spec apply_thread_view(user_id(), map(), guild_state(), map()) -> map().
apply_thread_view(UserId, #{thread_viewer := true} = Opts, State, GuildState) ->
    Member = guild_permissions_check:find_member_by_user_id(UserId, State),
    GuildState#{<<"threads">> => guild_thread_view:guild_threads(UserId, Opts, Member, State)};
apply_thread_view(UserId, _Opts, State, GuildState) ->
    Member = guild_permissions_check:find_member_by_user_id(UserId, State),
    Channels = guild_thread_view:hide_for_non_viewer(
        UserId, Member, State, maps:get(<<"channels">>, GuildState, [])
    ),
    Roles = [
        guild_thread_payload:mask_role(R)
     || R <- maps:get(<<"roles">>, GuildState, []), is_map(R)
    ],
    GuildState#{<<"channels">> => Channels, <<"roles">> => Roles}.

-spec base_guild_state(user_id(), guild_state()) -> map().
base_guild_state(UserId, State) ->
    Data = guild_data_index:ensure_data_map(State),
    GuildId = guild_id(State),
    AllChannels = guild_data_channels:channels_from_data(Data),
    Member = guild_permissions_check:find_member_by_user_id(UserId, State),
    {ViewableChannels, JoinedAt} = guild_data_channels:derive_member_view(
        UserId, Member, State, AllChannels
    ),
    OnlineCount = guild_member_list_read:get_online_count(State),
    OwnMemberList = own_member_list(Member),
    StateWithVoice = fetch_latest_voice_states(State),
    AllVoiceStates = guild_voice_state:get_voice_states_list(StateWithVoice),
    ViewableChannelIds = channel_id_set(ViewableChannels),
    VoiceStates = filter_voice_states(AllVoiceStates, ViewableChannelIds),
    VoiceMembers = resolve_voice_members(VoiceStates, Data),
    Members = guild_data_channels:merge_members(OwnMemberList, VoiceMembers),
    MemberCount = maps:get(member_count, State, guild_data_index_members:member_count(Data)),
    build_guild_state_map(
        GuildId,
        Data,
        ViewableChannels,
        Members,
        MemberCount,
        OnlineCount,
        VoiceStates,
        JoinedAt
    ).

-spec build_connect_snapshot(map() | [map()], guild_state()) -> map().
build_connect_snapshot(Item, State) when is_map(Item) ->
    build_connect_snapshot([Item], State);
build_connect_snapshot(Items, State) ->
    Base = maps:with(
        [
            id,
            data,
            sessions,
            member_count,
            voice_server_pid,
            voice_states,
            member_list_engine,
            virtual_channel_access
        ],
        State
    ),
    project_snapshot_sessions(maybe_trim_connect_snapshot(Items, Base, State)).

-spec project_snapshot_sessions(map()) -> map().
project_snapshot_sessions(#{sessions := Sessions} = Snapshot) when is_map(Sessions) ->
    Retained =
        case snapshot_reads_sessions(Snapshot) of
            true -> Sessions;
            false -> #{}
        end,
    Projected = maps:map(
        fun(_SessionId, SessionData) -> project_snapshot_session(SessionData) end,
        Retained
    ),
    Snapshot#{sessions => Projected};
project_snapshot_sessions(Snapshot) ->
    Snapshot.

-spec snapshot_reads_sessions(map()) -> boolean().
snapshot_reads_sessions(Snapshot) ->
    guild_availability_check:get_unavailability_mode_from_state(Snapshot) =:=
        unavailable_for_everyone_but_staff.

-spec project_snapshot_session(term()) -> term().
project_snapshot_session(SessionData) when is_map(SessionData) ->
    maps:without(?CONNECT_SNAPSHOT_HEAVY_SESSION_KEYS, SessionData);
project_snapshot_session(SessionData) ->
    SessionData.

-spec maybe_trim_connect_snapshot([map()], map(), guild_state()) -> map().
maybe_trim_connect_snapshot(Items, Base, State) ->
    case should_trim_connect_snapshot(State) of
        true -> trim_connect_snapshot(Items, Base);
        false -> Base
    end.

-spec should_trim_connect_snapshot(guild_state()) -> boolean().
should_trim_connect_snapshot(State) ->
    has_members_ets(State).

-spec has_members_ets(guild_state()) -> boolean().
has_members_ets(#{data := #{members_ets := Tab}}) -> is_reference(Tab);
has_members_ets(_) -> false.

-spec trim_connect_snapshot([map()], map()) -> map().
trim_connect_snapshot(Items, #{data := Data} = Base) when is_map(Data) ->
    Retained = retained_member_map(Items, Base, Data),
    Trimmed = maps:without(?CONNECT_SNAPSHOT_HEAVY_MEMBER_KEYS, Data),
    Base#{
        data => Trimmed#{
            <<"members">> => Retained,
            members_normalized => Retained,
            <<"member_role_index">> =>
                guild_data_index_members:build_member_role_index(Retained)
        }
    };
trim_connect_snapshot(_Items, Base) ->
    Base.

-spec retained_member_map([map()], map(), map()) -> #{integer() => map()}.
retained_member_map(Items, Base, Data) ->
    UserIds = [connect_user_id(Item) || Item <- Items] ++ voice_state_user_ids(Base),
    lists:foldl(
        fun(UserId, Acc) -> retain_member(UserId, Data, Acc) end,
        #{},
        UserIds
    ).

-spec retain_member(term(), map(), #{integer() => map()}) -> #{integer() => map()}.
retain_member(UserId, Data, Acc) when is_integer(UserId) ->
    case guild_data_index_members:get_member_ets(UserId, Data) of
        Member when is_map(Member) -> Acc#{UserId => Member};
        _ -> Acc
    end;
retain_member(_UserId, _Data, Acc) ->
    Acc.

-spec connect_user_id(map()) -> integer() | undefined.
connect_user_id(Item) ->
    Request = maps:get(request, Item, #{}),
    case maps:get(user_id, Request, undefined) of
        UserId when is_integer(UserId) -> UserId;
        _ -> undefined
    end.

-spec voice_state_user_ids(map()) -> [integer()].
voice_state_user_ids(Base) ->
    maps:fold(
        fun(_Key, VoiceState, Acc) -> add_voice_state_user_id(VoiceState, Acc) end,
        [],
        voice_state_utils:voice_states(Base)
    ).

-spec add_voice_state_user_id(term(), [integer()]) -> [integer()].
add_voice_state_user_id(VoiceState, Acc) when is_map(VoiceState) ->
    case voice_state_utils:voice_state_user_id(VoiceState) of
        UserId when is_integer(UserId) -> [UserId | Acc];
        _ -> Acc
    end;
add_voice_state_user_id(_VoiceState, Acc) ->
    Acc.

-spec resolve_voice_members([map()], map()) -> [map()].
resolve_voice_members(VoiceStates, Data) ->
    lists:filtermap(fun(VS) -> resolve_voice_member_entry(VS, Data) end, VoiceStates).

-spec resolve_voice_member_entry(map(), map()) -> {true, map()} | false.
resolve_voice_member_entry(VoiceState, Data) ->
    case maps:get(<<"member">>, VoiceState, undefined) of
        Member when is_map(Member), map_size(Member) > 0 ->
            {true, Member};
        _ ->
            resolve_voice_member_by_lookup(VoiceState, Data)
    end.

-spec resolve_voice_member_by_lookup(map(), map()) -> {true, map()} | false.
resolve_voice_member_by_lookup(VoiceState, Data) ->
    case voice_state_utils:voice_state_user_id(VoiceState) of
        UserId when is_integer(UserId) ->
            resolve_voice_member_from_index(UserId, Data);
        _ ->
            false
    end.

-spec resolve_voice_member_from_index(integer(), map()) -> {true, map()} | false.
resolve_voice_member_from_index(UserId, Data) ->
    case guild_data_index_members:get_member_ets(UserId, Data) of
        Member when is_map(Member) -> {true, Member};
        _ -> false
    end.

-spec fetch_latest_voice_states(guild_state()) -> guild_state().
fetch_latest_voice_states(State) ->
    case maps:get(voice_server_pid, State, undefined) of
        VoiceServerPid when is_pid(VoiceServerPid), VoiceServerPid =/= self() ->
            fetch_from_voice_pid(VoiceServerPid, State);
        _ ->
            fetch_from_voice_registry(State)
    end.

-spec get_guild_data_for_user(user_id(), map(), guild_state()) -> guild_reply(map()).
get_guild_data_for_user(UserId, Data, State) ->
    case guild_data_index_members:get_member(UserId, Data) of
        undefined ->
            {reply, #{guild_data => null, error_reason => <<"forbidden">>}, State};
        Member ->
            {GuildData, NewState} = build_member_guild_data(UserId, Member, Data, State),
            {reply, #{guild_data => GuildData}, NewState}
    end.

-spec build_complete_guild_data(map(), guild_state()) -> map().
build_complete_guild_data(Data, State) ->
    GuildProperties = maps:get(<<"guild">>, Data, #{}),
    Channels = map_utils:ensure_list(maps:get(<<"channels">>, Data, [])),
    maps:merge(GuildProperties, build_guild_collection_data(Data, Channels, State)).

-spec build_member_guild_data(user_id(), map(), map(), guild_state()) -> {map(), guild_state()}.
build_member_guild_data(UserId, Member, Data, State) ->
    GuildProperties = maps:get(<<"guild">>, Data, #{}),
    AllChannels = guild_data_channels:channels_from_data(Data),
    {ViewableChannels, NewState} = guild_data_channels:member_view(
        UserId, Member, State, AllChannels
    ),
    GuildData = maps:merge(
        GuildProperties, build_guild_collection_data(Data, ViewableChannels, State)
    ),
    {GuildData, NewState}.

-spec build_guild_collection_data(map(), [map()], guild_state()) -> map().
build_guild_collection_data(Data, Channels, State) ->
    #{
        <<"roles">> => map_utils:ensure_list(maps:get(<<"roles">>, Data, [])),
        <<"channels">> => map_utils:ensure_list(Channels),
        <<"emojis">> => map_utils:ensure_list(maps:get(<<"emojis">>, Data, [])),
        <<"stickers">> => map_utils:ensure_list(maps:get(<<"stickers">>, Data, [])),
        <<"member_count">> => maps:get(
            member_count, State, guild_data_index_members:member_count(Data)
        ),
        <<"online_count">> => guild_member_list_read:get_online_count(State)
    }.

-spec own_member_list(map() | undefined) -> [map()].
own_member_list(undefined) -> [];
own_member_list(M) -> [M].

-spec filter_voice_states([map()], sets:set(integer())) -> [map()].
filter_voice_states(AllVoiceStates, ViewableChannelIds) ->
    [
        voice_state_utils:sanitize_voice_state_for_broadcast(VS)
     || VS <- AllVoiceStates,
        voice_state_in_viewable_channel(VS, ViewableChannelIds)
    ].

-spec build_guild_state_map(
    guild_id() | undefined,
    map(),
    [map()],
    [map()],
    non_neg_integer(),
    non_neg_integer(),
    [map()],
    term()
) -> map().
build_guild_state_map(
    GuildId,
    Data,
    Channels,
    Members,
    MemberCount,
    OnlineCount,
    VoiceStates,
    JoinedAt
) ->
    #{
        <<"id">> => guild_id_wire_value(GuildId),
        <<"properties">> => maps:get(<<"guild">>, Data, #{}),
        <<"roles">> => map_utils:ensure_list(maps:get(<<"roles">>, Data, [])),
        <<"channels">> => Channels,
        <<"emojis">> => maps:get(<<"emojis">>, Data, []),
        <<"stickers">> => maps:get(<<"stickers">>, Data, []),
        <<"members">> => Members,
        <<"member_count">> => MemberCount,
        <<"online_count">> => OnlineCount,
        <<"presences">> => [],
        <<"voice_states">> => VoiceStates,
        <<"joined_at">> => JoinedAt
    }.

-spec fetch_from_voice_pid(pid(), guild_state()) -> guild_state().
fetch_from_voice_pid(VoiceServerPid, State) ->
    case erlang:process_info(VoiceServerPid, message_queue_len) of
        undefined ->
            fetch_from_voice_registry(maps:remove(voice_server_pid, State));
        {message_queue_len, Q} when Q >= 50 ->
            State;
        _ ->
            try_voice_call(VoiceServerPid, State)
    end.

-spec try_voice_call(pid(), guild_state()) -> guild_state().
try_voice_call(VoiceServerPid, State) ->
    try gen_server:call(VoiceServerPid, {get_voice_states_map}, 200) of
        VoiceStates when is_map(VoiceStates) ->
            State#{voice_states => voice_state_utils:ensure_voice_states(VoiceStates)};
        _ ->
            State#{voice_states => #{}}
    catch
        exit:{timeout, _} -> State;
        exit:_ -> fetch_from_voice_registry(maps:remove(voice_server_pid, State))
    end.

-spec fetch_from_voice_registry(guild_state()) -> guild_state().
fetch_from_voice_registry(State) ->
    case guild_id(State) of
        undefined -> State#{voice_states => #{}};
        GuildId -> fetch_from_voice_registry(GuildId, State)
    end.

-spec fetch_from_voice_registry(guild_id(), guild_state()) -> guild_state().
fetch_from_voice_registry(GuildId, State) ->
    case guild_voice_server:lookup_registered(GuildId) of
        {ok, VoiceServerPid} when VoiceServerPid =/= self() ->
            fetch_latest_voice_states(State#{voice_server_pid => VoiceServerPid});
        _ ->
            State#{voice_states => #{}}
    end.

-spec guild_id(guild_state()) -> guild_id() | undefined.
guild_id(State) ->
    Data = guild_data_index:ensure_data_map(State),
    Guild = map_utils:ensure_map(maps:get(<<"guild">>, Data, #{})),
    first_snowflake([
        maps:get(id, State, undefined),
        maps:get(<<"id">>, State, undefined),
        maps:get(<<"id">>, Guild, undefined)
    ]).

-spec first_snowflake([term()]) -> guild_id() | undefined.
first_snowflake([]) ->
    undefined;
first_snowflake([Value | Rest]) ->
    case snowflake_id:parse_optional(Value) of
        undefined -> first_snowflake(Rest);
        GuildId -> GuildId
    end.

-spec channel_id_set([map()]) -> sets:set(integer()).
channel_id_set(Channels) ->
    sets:from_list(channel_ids(Channels)).

-spec channel_ids([map()]) -> [integer()].
channel_ids(Channels) ->
    lists:filtermap(fun channel_id_item/1, Channels).

-spec channel_id_item(map()) -> {true, integer()} | false.
channel_id_item(Channel) ->
    SafeChannel = map_utils:ensure_map(Channel),
    case snowflake_id:parse_optional(maps:get(<<"id">>, SafeChannel, undefined)) of
        ChannelId when is_integer(ChannelId) -> {true, ChannelId};
        _ -> false
    end.

-spec voice_state_in_viewable_channel(map(), sets:set(integer())) -> boolean().
voice_state_in_viewable_channel(VoiceState, ViewableChannelIds) ->
    SafeVoiceState = map_utils:ensure_map(VoiceState),
    case snowflake_id:parse_optional(maps:get(<<"channel_id">>, SafeVoiceState, undefined)) of
        ChannelId when is_integer(ChannelId) -> sets:is_element(ChannelId, ViewableChannelIds);
        _ -> false
    end.

-spec guild_id_wire_value(guild_id() | undefined) -> binary() | null.
guild_id_wire_value(undefined) ->
    null;
guild_id_wire_value(GuildId) ->
    integer_to_binary(GuildId).