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_dispatch).
-typing([eqwalizer]).
-include_lib("kernel/include/logger.hrl").
-export([
handle_dispatch/3,
normalize_event/1,
is_member_list_updates_enabled/1
]).
-type guild_state() :: map().
-type event() :: atom().
-type event_data() :: map().
-type dispatch_mode() :: full | state_only.
-spec normalize_event(atom() | binary()) -> atom() | binary().
normalize_event(Event) when is_atom(Event) ->
Event;
normalize_event(Event) when is_binary(Event) ->
event_atoms:normalize(Event).
-spec handle_dispatch(atom() | binary(), map(), map()) -> {noreply, map()}.
handle_dispatch(Event, EventData, State) ->
Mode =
case should_skip_dispatch(Event, State) of
true -> state_only;
false -> full
end,
normalized_event_atom(normalize_event(Event), EventData, Mode, State).
-spec normalized_event_atom(atom() | binary(), event_data(), dispatch_mode(), guild_state()) ->
{noreply, guild_state()}.
normalized_event_atom(Event, EventData, Mode, State) when is_atom(Event) ->
process_dispatch(Event, EventData, Mode, State);
normalized_event_atom(_Event, _EventData, state_only, State) ->
{noreply, State};
normalized_event_atom(Event, _EventData, full, State) when is_binary(Event) ->
?LOG_WARNING("guild dispatch dropped unknown event: event=~ts guild_id=~p", [
Event, maps:get(id, State, undefined)
]),
{noreply, State}.
-spec should_skip_dispatch(term(), guild_state()) -> boolean().
should_skip_dispatch(guild_update, _State) ->
false;
should_skip_dispatch(_Event, State) ->
Data = maps:get(data, State),
Guild = maps:get(<<"guild">>, Data, #{}),
Features = maps:get(<<"features">>, Guild, []),
lists:member(<<"UNAVAILABLE_FOR_EVERYONE">>, Features) orelse
lists:member(<<"UNAVAILABLE_FOR_EVERYONE_BUT_STAFF">>, Features).
-spec process_dispatch(event(), event_data(), dispatch_mode(), guild_state()) ->
{noreply, guild_state()}.
process_dispatch(Event, EventData, Mode, State) ->
case
{
guild_thread_gate:pre_update_filter(Event, EventData, State),
guild_thread_dispatch:handles(Event)
}
of
{drop, _HandlesThread} ->
ok = maybe_self_heal(State),
{noreply, guild_thread_flip:hold(Event, EventData, State)};
{{filtered, FilteredData}, _HandlesThread} ->
ok = maybe_self_heal(State),
process_regular_dispatch(
Event, FilteredData, Mode, guild_thread_flip:hold(Event, EventData, State)
);
{pass, true} ->
State1 = guild_thread_flip:hold(Event, EventData, State),
guild_thread_dispatch:handle(Event, EventData, Mode, State1);
{pass, false} ->
State1 = guild_thread_flip:hold(Event, EventData, State),
process_regular_dispatch(Event, EventData, Mode, State1)
end.
-spec maybe_self_heal(guild_state()) -> ok.
maybe_self_heal(#{id := GuildId}) when is_integer(GuildId) ->
case channel_threads_config:guild_active(GuildId) of
true -> channel_threads_flip:self_heal(GuildId);
false -> ok
end;
maybe_self_heal(_State) ->
ok.
-spec process_regular_dispatch(event(), event_data(), dispatch_mode(), guild_state()) ->
{noreply, guild_state()}.
process_regular_dispatch(Event, EventData, state_only, State) ->
{_SessionIdOpt, _FinalData, UpdatedState} = apply_regular_event(Event, EventData, State),
{noreply, UpdatedState};
process_regular_dispatch(Event, EventData, full, State) ->
GuildId = maps:get(id, State),
{SessionIdOpt, FinalData0, UpdatedState} = apply_regular_event(Event, EventData, State),
FilterState = filter_state_for_event(Event, State, UpdatedState),
Sessions = maps:get(sessions, UpdatedState),
FilteredSessions = filter_dispatch_sessions(
Event, FinalData0, SessionIdOpt, Sessions, FilterState
),
FinalData = strip_thread_internal(FinalData0, UpdatedState),
?LOG_DEBUG(
"process_dispatch: event=~p guild_id=~p total_sessions=~p filtered_sessions=~p",
[Event, GuildId, map_size(Sessions), length(FilteredSessions)]
),
lists:foreach(
fun({Group, GroupData}) ->
guild_dispatch_send:dispatch_to_sessions(Group, Event, GroupData, UpdatedState)
end,
guild_thread_payload:starter_variants(Event, FinalData, FilteredSessions, UpdatedState)
),
guild_dispatch_push:maybe_send_push_notifications(Event, FinalData, GuildId, UpdatedState),
FinalState = guild_dispatch_member_list:maybe_broadcast_member_list_update(
Event, FinalData, State, UpdatedState
),
{noreply, FinalState}.
-spec apply_regular_event(event(), event_data(), guild_state()) ->
{binary() | undefined, event_data(), guild_state()}.
apply_regular_event(Event, EventData, State) ->
GuildId = maps:get(id, State),
{SessionIdOpt, CleanData} = extract_session_id_if_needed(Event, EventData, State),
DecoratedData = CleanData#{<<"guild_id">> => integer_to_binary(GuildId)},
FinalData0 = guild_dispatch_decorate:decorate_member_data(Event, DecoratedData, State),
UpdatedState0 = guild_state:update_state(Event, FinalData0, State),
UpdatedState = guild_state_threads:after_regular_event(Event, FinalData0, UpdatedState0),
{SessionIdOpt, FinalData0, UpdatedState}.
-spec filter_dispatch_sessions(
event(), event_data(), binary() | undefined, map(), guild_state()
) -> [{binary(), map()}].
filter_dispatch_sessions(Event, Data, SessionIdOpt, Sessions, State) ->
case guild_thread_gate:event_scope(Event, Data, State) of
open ->
guild_dispatch_filter:filter_sessions_for_event(
Event, Data, SessionIdOpt, Sessions, State
);
viewers ->
guild_dispatch_filter:filter_sessions_for_event(
Event, Data, SessionIdOpt, guild_thread_gate:viewer_sessions(Sessions), State
);
{thread, ThreadId, Thread} ->
guild_thread_gate:thread_sessions(
Event, Data, ThreadId, Thread, SessionIdOpt, State
)
end.
-spec strip_thread_internal(event_data(), guild_state()) -> event_data().
strip_thread_internal(Data, State) ->
case guild_thread_gate:needs_variant(State) of
true -> guild_thread_payload:strip_internal(Data);
false -> Data
end.
-spec filter_state_for_event(event(), guild_state(), guild_state()) -> guild_state().
filter_state_for_event(channel_delete, PreviousState, _UpdatedState) ->
PreviousState;
filter_state_for_event(_Event, _PreviousState, UpdatedState) ->
UpdatedState.
-spec extract_session_id_if_needed(event(), event_data(), guild_state()) ->
{binary() | undefined, event_data()}.
extract_session_id_if_needed(Event, EventData, State) when
Event =:= message_reaction_add; Event =:= message_reaction_remove
->
{SessionIdOpt, CleanData} = guild_dispatch_decorate:extract_and_remove_session_id(
EventData
),
{actor_session_id(SessionIdOpt, EventData, State), CleanData};
extract_session_id_if_needed(_, EventData, _State) ->
{undefined, EventData}.
-spec actor_session_id(binary() | undefined, event_data(), guild_state()) ->
binary() | undefined.
actor_session_id(undefined, _EventData, _State) ->
undefined;
actor_session_id(SessionId, EventData, State) ->
ActorId = guild_dispatch_decorate:parse_snowflake(
<<"user_id">>, maps:get(<<"user_id">>, EventData, undefined)
),
case maps:get(SessionId, maps:get(sessions, State, #{}), undefined) of
#{user_id := UserId} when is_integer(ActorId), UserId =:= ActorId -> SessionId;
_ -> undefined
end.
-spec is_member_list_updates_enabled(map()) -> boolean().
is_member_list_updates_enabled(State) ->
guild_dispatch_config:is_member_list_updates_enabled(State).