A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
%% 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).