Skip to content

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

TypeScript fluxerfluxerapp

refactor(gateway): separate thread payload masking, drop tests

Hampus45e43a050623
diff --git a/fluxer_gateway/src/guild/guild_data.erl b/fluxer_gateway/src/guild/guild_data.erl
index c4c31ac98..4f35fc915 100644
--- a/fluxer_gateway/src/guild/guild_data.erl
+++ b/fluxer_gateway/src/guild/guild_data.erl
@@ -25,9 +25,9 @@
]).
-define(CONNECT_SNAPSHOT_HEAVY_SESSION_KEYS, [active_guilds, user_roles, viewable_channels]).
--export_type([guild_state/0, guild_reply/1, user_id/0]).
+-export_type([guild_state/0]).
--spec get_guild_data(map(), guild_state()) -> guild_reply(map()).
+-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
@@ -38,7 +38,7 @@ get_guild_data(#{user_id := UserId}, State) ->
get_guild_data_for_user(UserId, Data, State)
end.
--spec get_auth_context(map(), guild_state()) -> guild_reply(map()).
+-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
@@ -97,7 +97,7 @@ find_thread_parent_channel(ChannelId, Index, Data) when is_integer(ChannelId) ->
find_thread_parent_channel(_ChannelId, _Index, _Data) ->
null.
--spec get_first_viewable_text_channel(guild_state()) -> guild_reply(map()).
+-spec get_first_viewable_text_channel(guild_state()) -> {reply, map(), guild_state()}.
get_first_viewable_text_channel(State) ->
get_everyone_viewable_text_channel(State).
@@ -109,11 +109,11 @@ get_everyone_viewable_text_channel(State) ->
),
{reply, #{channel_id => EveryoneChannelId}, State}.
--spec get_guild_state(user_id(), guild_state()) -> map().
+-spec get_guild_state(integer(), guild_state()) -> map().
get_guild_state(UserId, State) ->
get_guild_state(UserId, State, #{}).
--spec get_guild_state(user_id(), guild_state(), map()) -> map().
+-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
@@ -131,7 +131,7 @@ apply_thread_view(UserId, _Opts, State, GuildState) ->
UserId, Member, State, maps:get(<<"channels">>, GuildState, [])
),
Roles = [
- guild_thread_gate:mask_role(R)
+ guild_thread_payload:mask_role(R)
|| R <- maps:get(<<"roles">>, GuildState, []), is_map(R)
],
GuildState#{<<"channels">> => Channels, <<"roles">> => Roles}.
@@ -186,16 +186,16 @@ build_connect_snapshot(Items, State) ->
-spec project_snapshot_sessions(map()) -> map().
project_snapshot_sessions(#{sessions := Sessions} = Snapshot) when is_map(Sessions) ->
- case snapshot_reads_sessions(Snapshot) of
- true ->
- Projected = maps:map(
- fun(_SessionId, SessionData) -> project_snapshot_session(SessionData) end,
- Sessions
- ),
- Snapshot#{sessions => Projected};
- false ->
- Snapshot#{sessions => #{}}
- end;
+ 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.
@@ -496,91 +496,3 @@ guild_id_wire_value(undefined) ->
null;
guild_id_wire_value(GuildId) ->
integer_to_binary(GuildId).
-
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
-
-staff_only_data() ->
- #{<<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE_BUT_STAFF">>]}}.
-
-projection_snapshot() ->
- #{
- data => staff_only_data(),
- sessions => #{
- <<"s1">> => #{
- session_id => <<"s1">>,
- user_id => 7,
- pid => self(),
- bot => false,
- is_staff => true,
- pending_connect => false,
- active_guilds => sets:new(),
- user_roles => [1, 2],
- viewable_channels => #{10 => true}
- }
- }
- }.
-
-projection_entry(Snapshot) ->
- maps:get(<<"s1">>, maps:get(sessions, Snapshot)).
-
-project_snapshot_sessions_drops_only_heavy_keys_test() ->
- Entry = projection_entry(project_snapshot_sessions(projection_snapshot())),
- ?assertEqual(7, maps:get(user_id, Entry)),
- ?assertEqual(true, maps:get(is_staff, Entry)),
- ?assertEqual(false, maps:get(pending_connect, Entry)),
- ?assertEqual(<<"s1">>, maps:get(session_id, Entry)),
- ?assertNot(maps:is_key(active_guilds, Entry)),
- ?assertNot(maps:is_key(user_roles, Entry)),
- ?assertNot(maps:is_key(viewable_channels, Entry)).
-
-projection_keeps_session_staff_lookup_test() ->
- Projected = project_snapshot_sessions(projection_snapshot()),
- ?assertEqual(true, guild_availability_check:is_user_staff(7, Projected)).
-
-projection_leaves_snapshot_data_untouched_test() ->
- Data = #{<<"members">> => #{7 => #{}}, members_ets => make_ref()},
- Snapshot = maps:put(data, Data, projection_snapshot()),
- ?assertEqual(Data, maps:get(data, project_snapshot_sessions(Snapshot))).
-
-projection_keeps_non_map_session_entries_test() ->
- Snapshot = #{data => staff_only_data(), sessions => #{<<"broken">> => not_a_map}},
- ?assertEqual(Snapshot, project_snapshot_sessions(Snapshot)).
-
-projection_drops_sessions_unless_staff_only_test() ->
- Snapshot = projection_snapshot(),
- lists:foreach(
- fun(Data) ->
- Projected = project_snapshot_sessions(Snapshot#{data => Data}),
- ?assertEqual(#{}, maps:get(sessions, Projected)),
- ?assertEqual(Data, maps:get(data, Projected))
- end,
- [
- #{},
- #{<<"guild">> => #{<<"features">> => []}},
- #{<<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE">>]}}
- ]
- ).
-
-projection_keeps_snapshot_without_sessions_test() ->
- Snapshot = #{id => 42, member_count => 3},
- ?assertEqual(Snapshot, project_snapshot_sessions(Snapshot)).
-
-trim_state(MemberCount) ->
- #{id => 42, member_count => MemberCount, data => #{members_ets => make_ref()}}.
-
-trim_applies_at_every_member_count_test() ->
- ?assertEqual(true, should_trim_connect_snapshot(trim_state(49435))),
- ?assertEqual(true, should_trim_connect_snapshot(trim_state(5000))),
- ?assertEqual(true, should_trim_connect_snapshot(trim_state(1))),
- ?assertEqual(true, should_trim_connect_snapshot(maps:remove(member_count, trim_state(1)))).
-
-trim_needs_members_ets_test() ->
- ?assertEqual(false, should_trim_connect_snapshot(#{member_count => 10, data => #{}})),
- ?assertEqual(
- false,
- should_trim_connect_snapshot(#{member_count => 10, data => #{members_ets => 7}})
- ),
- ?assertEqual(false, should_trim_connect_snapshot(#{member_count => 10})).
-
--endif.
diff --git a/fluxer_gateway/src/guild/guild_dispatch.erl b/fluxer_gateway/src/guild/guild_dispatch.erl
index ba5b96b44..6a1dac18f 100644
--- a/fluxer_gateway/src/guild/guild_dispatch.erl
+++ b/fluxer_gateway/src/guild/guild_dispatch.erl
@@ -10,7 +10,6 @@
normalize_event/1,
is_member_list_updates_enabled/1
]).
--export_type([event/0, event_data/0, guild_state/0]).
-type guild_state() :: map().
-type event() :: atom().
@@ -22,7 +21,7 @@ normalize_event(Event) when is_atom(Event) ->
normalize_event(Event) when is_binary(Event) ->
event_atoms:normalize(Event).
--spec handle_dispatch(term(), event_data(), guild_state()) -> {noreply, guild_state()}.
+-spec handle_dispatch(atom() | binary(), map(), map()) -> {noreply, map()}.
handle_dispatch(Event, EventData, State) ->
case should_skip_dispatch(Event, State) of
true ->
@@ -45,7 +44,7 @@ normalized_event_atom(Event, _EventData, State) when is_binary(Event) ->
should_skip_dispatch(guild_update, _State) ->
false;
should_skip_dispatch(_Event, State) ->
- Data = maps:get(data, State, #{}),
+ Data = maps:get(data, State),
Guild = maps:get(<<"guild">>, Data, #{}),
Features = maps:get(<<"features">>, Guild, []),
lists:member(<<"UNAVAILABLE_FOR_EVERYONE">>, Features) orelse
@@ -53,21 +52,26 @@ should_skip_dispatch(_Event, State) ->
-spec process_dispatch(event(), event_data(), guild_state()) -> {noreply, guild_state()}.
process_dispatch(Event, EventData, State) ->
- case guild_thread_gate:pre_update_filter(Event, EventData, State) of
- drop ->
+ 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} ->
+ {{filtered, FilteredData}, _HandlesThread} ->
ok = maybe_self_heal(State),
process_regular_dispatch(
Event, FilteredData, guild_thread_flip:hold(Event, EventData, State)
);
- pass ->
+ {pass, true} ->
+ State1 = guild_thread_flip:hold(Event, EventData, State),
+ guild_thread_dispatch:handle(Event, EventData, State1);
+ {pass, false} ->
State1 = guild_thread_flip:hold(Event, EventData, State),
- case guild_thread_dispatch:handles(Event) of
- true -> guild_thread_dispatch:handle(Event, EventData, State1);
- false -> process_regular_dispatch(Event, EventData, State1)
- end
+ process_regular_dispatch(Event, EventData, State1)
end.
-spec maybe_self_heal(guild_state()) -> ok.
@@ -89,7 +93,7 @@ process_regular_dispatch(Event, EventData, State) ->
UpdatedState0 = guild_state:update_state(Event, FinalData0, State),
UpdatedState = guild_state_threads:after_regular_event(Event, FinalData0, UpdatedState0),
FilterState = filter_state_for_event(Event, State, UpdatedState),
- Sessions = maps:get(sessions, UpdatedState, #{}),
+ Sessions = maps:get(sessions, UpdatedState),
FilteredSessions = filter_dispatch_sessions(
Event, FinalData0, SessionIdOpt, Sessions, FilterState
),
@@ -127,7 +131,7 @@ filter_dispatch_sessions(Event, Data, SessionIdOpt, Sessions, State) ->
-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_gate:strip_internal(Data);
+ true -> guild_thread_payload:strip_internal(Data);
false -> Data
end.
@@ -146,176 +150,6 @@ extract_session_id_if_needed(message_reaction_remove, EventData) ->
extract_session_id_if_needed(_, EventData) ->
{undefined, EventData}.
--spec is_member_list_updates_enabled(guild_state()) -> boolean().
+-spec is_member_list_updates_enabled(map()) -> boolean().
is_member_list_updates_enabled(State) ->
guild_dispatch_config:is_member_list_updates_enabled(State).
-
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
-
-should_skip_dispatch_guild_update_never_skipped_test() ->
- State = #{
- data => #{
- <<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE">>]}
- }
- },
- ?assertEqual(false, should_skip_dispatch(guild_update, State)).
-
-should_skip_dispatch_unavailable_for_everyone_test() ->
- State = #{
- data => #{
- <<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE">>]}
- }
- },
- ?assertEqual(true, should_skip_dispatch(message_create, State)).
-
-should_skip_dispatch_unavailable_for_everyone_but_staff_test() ->
- State = #{
- data => #{
- <<"guild">> => #{<<"features">> => [<<"UNAVAILABLE_FOR_EVERYONE_BUT_STAFF">>]}
- }
- },
- ?assertEqual(true, should_skip_dispatch(message_create, State)).
-
-unknown_binary_event_is_dropped_without_crashing_test() ->
- State = #{id => 1, data => #{<<"guild">> => #{}}, sessions => #{}},
- ?assertEqual(
- {noreply, State},
- handle_dispatch(<<"FUTURE_EVENT_THE_GATEWAY_HAS_NEVER_SEEN">>, #{}, State)
- ).
-
-normalize_event_keeps_unknown_binaries_test() ->
- ?assertEqual(<<"FUTURE_EVENT_ZZZ">>, normalize_event(<<"FUTURE_EVENT_ZZZ">>)),
- ?assertEqual(thread_create, normalize_event(<<"THREAD_CREATE">>)).
-
-channel_delete_dispatch_filters_by_pre_delete_visibility_test() ->
- Parent = self(),
- VisiblePid = start_dispatch_capture(visible, Parent),
- HiddenPid = start_dispatch_capture(hidden, Parent),
- try
- State = build_channel_delete_dispatch_state(VisiblePid, HiddenPid),
- HiddenMember = guild_permissions_check:find_member_by_user_id(1001, State),
- VisibleMember = guild_permissions_check:find_member_by_user_id(1002, State),
- ?assertEqual(
- false, guild_permissions_check:can_view_channel(1001, 10, HiddenMember, State)
- ),
- ?assertEqual(
- true, guild_permissions_check:can_view_channel(1002, 10, VisibleMember, State)
- ),
- {noreply, _} = handle_dispatch(channel_delete, #{<<"id">> => <<"10">>}, State),
- assert_visible_channel_delete_dispatched(),
- assert_hidden_channel_delete_not_dispatched()
- after
- VisiblePid ! stop,
- HiddenPid ! stop
- end.
-
--spec start_dispatch_capture(atom(), pid()) -> pid().
-start_dispatch_capture(Tag, Parent) ->
- spawn(fun() -> dispatch_capture_loop(Tag, Parent) end).
-
--spec dispatch_capture_loop(atom(), pid()) -> ok.
-dispatch_capture_loop(Tag, Parent) ->
- receive
- stop ->
- ok;
- {'$gen_cast', Msg} ->
- Parent ! {Tag, Msg},
- dispatch_capture_loop(Tag, Parent);
- _Other ->
- dispatch_capture_loop(Tag, Parent)
- after 5000 ->
- dispatch_capture_loop(Tag, Parent)
- end.
-
--spec assert_visible_channel_delete_dispatched() -> ok.
-assert_visible_channel_delete_dispatched() ->
- receive
- {visible, {dispatch, channel_delete, Payload0}} ->
- Payload = decode_dispatch_payload(Payload0),
- ?assertEqual(<<"10">>, maps:get(<<"id">>, Payload));
- {visible, Other} ->
- ?assert(false, {unexpected_visible_message, Other})
- after 1000 ->
- ?assert(false, visible_channel_delete_not_dispatched)
- end.
-
--spec assert_hidden_channel_delete_not_dispatched() -> ok.
-assert_hidden_channel_delete_not_dispatched() ->
- receive
- {hidden, {dispatch, channel_delete, _Payload}} ->
- ?assert(false, hidden_user_received_channel_delete)
- after 200 ->
- ok
- end.
-
--spec decode_dispatch_payload(term()) -> map().
-decode_dispatch_payload({pre_encoded, Bin}) when is_binary(Bin) ->
- decoded_dispatch_payload(json:decode(Bin));
-decode_dispatch_payload(Map) when is_map(Map) ->
- Map.
-
--spec decoded_dispatch_payload(term()) -> map().
-decoded_dispatch_payload(Payload) when is_map(Payload) ->
- Payload.
-
--spec build_channel_delete_dispatch_state(pid(), pid()) -> guild_state().
-build_channel_delete_dispatch_state(VisiblePid, HiddenPid) ->
- GuildId = 1,
- GuildIdBin = integer_to_binary(GuildId),
- ViewPermissionBin = integer_to_binary(constants:view_channel_permission()),
- #{
- id => GuildId,
- member_count => 100,
- sessions => build_test_sessions(GuildId, VisiblePid, HiddenPid),
- data => build_test_data(GuildIdBin, ViewPermissionBin),
- member_list_subscriptions => guild_member_list_subs:new()
- }.
-
--spec build_test_sessions(integer(), pid(), pid()) -> map().
-build_test_sessions(GuildId, VisiblePid, HiddenPid) ->
- #{
- <<"visible">> => #{
- user_id => 1002,
- pid => VisiblePid,
- active_guilds => sets:from_list([GuildId])
- },
- <<"hidden">> => #{
- user_id => 1001,
- pid => HiddenPid,
- active_guilds => sets:from_list([GuildId])
- }
- }.
-
--spec build_test_data(binary(), binary()) -> map().
-build_test_data(GuildIdBin, ViewPermissionBin) ->
- #{
- <<"guild">> => #{
- <<"id">> => GuildIdBin,
- <<"owner_id">> => <<"999">>,
- <<"features">> => []
- },
- <<"roles">> => [
- #{<<"id">> => GuildIdBin, <<"permissions">> => ViewPermissionBin},
- #{<<"id">> => <<"200">>, <<"permissions">> => <<"0">>}
- ],
- <<"members">> => [
- #{<<"user">> => #{<<"id">> => <<"1001">>}, <<"roles">> => [<<"200">>]},
- #{<<"user">> => #{<<"id">> => <<"1002">>}, <<"roles">> => []}
- ],
- <<"channels">> => [
- #{
- <<"id">> => <<"10">>,
- <<"permission_overwrites">> => [
- #{
- <<"id">> => <<"200">>,
- <<"type">> => 0,
- <<"allow">> => <<"0">>,
- <<"deny">> => ViewPermissionBin
- }
- ]
- }
- ]
- }.
-
--endif.
diff --git a/fluxer_gateway/src/guild/guild_dispatch_send.erl b/fluxer_gateway/src/guild/guild_dispatch_send.erl
index 04a0a8e91..5baa43f17 100644
--- a/fluxer_gateway/src/guild/guild_dispatch_send.erl
+++ b/fluxer_gateway/src/guild/guild_dispatch_send.erl
@@ -16,14 +16,12 @@
-type guild_state() :: map().
-type session_id() :: binary().
-type guild_id() :: integer().
--type user_id() :: integer().
-type session_pair() :: {session_id(), map()}.
-type bulk_group_key() :: [term()].
-type bulk_groups() :: #{bulk_group_key() => {[map()], [pid()]}}.
-type bulk_acc() :: {bulk_groups(), non_neg_integer()}.
--export_type([event/0, event_data/0, guild_state/0, user_id/0, session_pair/0]).
--spec dispatch_to_sessions([session_pair()], event(), event_data(), guild_state()) ->
+-spec dispatch_to_sessions([{binary(), map()}], atom(), map(), map()) ->
non_neg_integer().
dispatch_to_sessions(FilteredSessions, Event, FinalData, UpdatedState) ->
case guild_thread_gate:needs_variant(UpdatedState) of
@@ -36,7 +34,7 @@ dispatch_to_sessions(FilteredSessions, Event, FinalData, UpdatedState) ->
-spec dispatch_masked_variants([session_pair()], event(), event_data(), guild_state()) ->
non_neg_integer().
dispatch_masked_variants(FilteredSessions, Event, FinalData, UpdatedState) ->
- Masked = guild_thread_gate:mask_payload(Event, FinalData),
+ Masked = guild_thread_payload:mask_payload(Event, FinalData),
{Viewers, Others} = lists:partition(
fun({_Sid, Session}) -> guild_thread_gate:session_viewer(Session) end, FilteredSessions
),
@@ -323,204 +321,3 @@ normalize_success(_) -> 0.
-spec normalize_dispatched([pid()]) -> non_neg_integer().
normalize_dispatched([]) -> 0;
normalize_dispatched([_ | _]) -> 1.
-
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
-
--define(OVERFLOW_CHANNEL_BITS, 11).
-
-passive_channel_update_bulk_dispatches_visible_channels_test() ->
- flush_dispatches(),
- Data = #{
- <<"guild_id">> => <<"42">>,
- <<"channels">> => [
- #{<<"id">> => <<"100">>, <<"name">> => <<"visible">>},
- #{<<"id">> => <<"200">>, <<"name">> => <<"hidden">>}
- ]
- },
- ?assertEqual(
- 1,
- dispatch_to_sessions(
- [passive_session_pair()], channel_update_bulk, Data, passive_dispatch_state()
- )
- ),
- Payload = receive_pre_encoded_payload(channel_update_bulk),
- ?assertEqual(
- [#{<<"id">> => <<"100">>, <<"name">> => <<"visible">>}],
- maps:get(<<"channels">>, Payload)
- ).
-
-grouped_bulk_encodes_once_per_visible_set_test() ->
- flush_dispatches(),
- Data = bulk_channel_data(),
- State = passive_dispatch_state(),
- Sessions = [
- bulk_session_pair(<<"a">>, #{100 => true}),
- bulk_session_pair(<<"b">>, #{100 => true}),
- bulk_session_pair(<<"c">>, #{200 => true})
- ],
- ?assertEqual(1, dispatch_to_sessions(Sessions, channel_update_bulk, Data, State)),
- Bins = [receive_pre_encoded_binary(channel_update_bulk) || _ <- lists:seq(1, 3)],
- ?assertEqual(2, length(lists:usort(Bins))),
- Sets = [maps:get(<<"channels">>, json:decode(Bin)) || Bin <- Bins],
- ?assertEqual(2, length([S || S <- Sets, S =:= [bulk_channel(<<"100">>, <<"first">>)]])),
- ?assertEqual(1, length([S || S <- Sets, S =:= [bulk_channel(<<"200">>, <<"second">>)]])).
-
-grouped_bulk_skips_sessions_without_visible_channels_test() ->
- flush_dispatches(),
- Data = bulk_channel_data(),
- State = passive_dispatch_state(),
- Sessions = [
- bulk_session_pair(<<"a">>, #{}),
- bulk_session_pair(<<"b">>, #{200 => true})
- ],
- ?assertEqual(1, dispatch_to_sessions(Sessions, channel_update_bulk, Data, State)),
- ?assertEqual(
- [bulk_channel(<<"200">>, <<"second">>)],
- maps:get(<<"channels">>, receive_pre_encoded_payload(channel_update_bulk))
- ),
- ?assertEqual(ok, assert_no_further_dispatch()).
-
-grouped_bulk_dispatches_overflow_recipients_without_retaining_them_test() ->
- flush_dispatches(),
- Total = ?MAX_BULK_ENCODE_GROUPS + 1,
- State = passive_dispatch_state(),
- Data = #{
- <<"guild_id">> => <<"42">>,
- <<"channels">> => [
- bulk_channel(integer_to_binary(Id), <<"c">>)
- || Id <- lists:seq(1, ?OVERFLOW_CHANNEL_BITS)
- ]
- },
- Sessions = [overflow_session_pair(N) || N <- lists:seq(1, Total)],
- ?assertEqual(1, dispatch_to_sessions(Sessions, channel_update_bulk, Data, State)),
- Received = collect_bulk_channel_ids(Total, []),
- Expected = [overflow_channel_ids(N) || N <- lists:seq(1, Total)],
- ?assertEqual(lists:sort(Expected), lists:sort(Received)),
- ?assertEqual(ok, assert_no_further_dispatch()).
-
-overflow_session_pair(N) ->
- Base = passive_session_data(),
- Sid = integer_to_binary(N),
- Viewable = maps:from_list([{Id, true} || Id <- overflow_visible_ids(N)]),
- {Sid, Base#{session_id => Sid, viewable_channels => Viewable}}.
-
-overflow_visible_ids(N) ->
- [Id || Id <- lists:seq(1, ?OVERFLOW_CHANNEL_BITS), (N bsr (Id - 1)) band 1 =:= 1].
-
-overflow_channel_ids(N) ->
- [integer_to_binary(Id) || Id <- overflow_visible_ids(N)].
-
-collect_bulk_channel_ids(0, Acc) ->
- Acc;
-collect_bulk_channel_ids(N, Acc) ->
- Payload = receive_pre_encoded_payload(channel_update_bulk),
- Ids = [maps:get(<<"id">>, Ch) || Ch <- maps:get(<<"channels">>, Payload)],
- collect_bulk_channel_ids(N - 1, [Ids | Acc]).
-
-bulk_channel_data() ->
- #{
- <<"guild_id">> => <<"42">>,
- <<"channels">> => [
- bulk_channel(<<"100">>, <<"first">>),
- bulk_channel(<<"200">>, <<"second">>)
- ]
- }.
-
-bulk_channel(Id, Name) ->
- #{<<"id">> => Id, <<"name">> => Name}.
-
-bulk_session_pair(Sid, ViewableChannels) ->
- Base = passive_session_data(),
- {Sid, Base#{session_id => Sid, viewable_channels => ViewableChannels}}.
-
-assert_no_further_dispatch() ->
- receive
- {'$gen_cast', {dispatch, Event, _Payload}} ->
- ?assert(false, {unexpected_dispatch, Event})
- after 0 ->
- ok
- end.
-
-standard_dispatch_without_eligible_sessions_test() ->
- flush_dispatches(),
- Session = (passive_session_data())#{pid => undefined},
- ?assertEqual(
- 0,
- dispatch_to_sessions(
- [{<<"offline">>, Session}],
- guild_update,
- #{<<"guild_id">> => <<"42">>, <<"name">> => <<"Updated">>},
- passive_dispatch_state()
- )
- ),
- assert_no_dispatch().
-
-standard_dispatch_ignores_ineligible_sessions_test() ->
- flush_dispatches(),
- Offline = (passive_session_data())#{pid => undefined},
- ?assertEqual(
- 1,
- dispatch_to_sessions(
- [{<<"offline">>, Offline}, passive_session_pair()],
- guild_update,
- #{<<"guild_id">> => <<"42">>, <<"name">> => <<"Updated">>},
- passive_dispatch_state()
- )
- ),
- _Payload = receive_pre_encoded_payload(guild_update),
- assert_no_dispatch().
-
-assert_no_dispatch() ->
- receive
- {'$gen_cast', {dispatch, Event, _Payload}} ->
- ?assert(false, {unexpected_dispatch, Event})
- after 100 ->
- ok
- end.
-
-passive_session_pair() ->
- {<<"passive">>, passive_session_data()}.
-
-passive_session_data() ->
- #{
- session_id => <<"passive">>,
- user_id => 10,
- pid => self(),
- active_guilds => sets:new(),
- bot => false,
- viewable_channels => #{100 => true}
- }.
-
-passive_dispatch_state() ->
- #{
- id => 42,
- member_count => 300,
- data => #{
- <<"guild">> => #{<<"owner_id">> => <<"999">>},
- <<"roles">> => [],
- <<"members">> => [],
- <<"channels">> => []
- }
- }.
-
-receive_pre_encoded_payload(Event) ->
- json:decode(receive_pre_encoded_binary(Event)).
-
-receive_pre_encoded_binary(Event) ->
- receive
- {'$gen_cast', {dispatch, Event, {pre_encoded, Bin}}} ->
- Bin
- after 1000 ->
- ?assert(false, {dispatch_not_received, Event})
- end.
-
-flush_dispatches() ->
- receive
- {'$gen_cast', {dispatch, _Event, _Payload}} ->
- flush_dispatches()
- after 0 ->
- ok
- end.
-
--endif.
diff --git a/fluxer_gateway/src/guild/guild_thread_dispatch.erl b/fluxer_gateway/src/guild/guild_thread_dispatch.erl
index 66707e226..28b328674 100644
--- a/fluxer_gateway/src/guild/guild_thread_dispatch.erl
+++ b/fluxer_gateway/src/guild/guild_thread_dispatch.erl
@@ -14,6 +14,7 @@
]).
-define(RECENT_CREATE_CAP, 256).
+-define(PRIVATE_THREAD, 12).
-define(COUNTS_KEY, {?MODULE, variant_counts}).
-define(EVENTS, [
thread_create,
@@ -51,7 +52,7 @@ handles(thread_member_list_update) -> true;
handles(forum_unreads) -> true;
handles(_) -> false.
--spec handle(atom(), map(), guild_state()) -> {noreply, guild_state()}.
+-spec handle(atom(), map(), map()) -> {noreply, map()}.
handle(Event, EventData, #{id := GuildId} = State) when is_integer(GuildId) ->
Data = EventData#{<<"guild_id">> => integer_to_binary(GuildId)},
try
@@ -170,8 +171,8 @@ shared_memo(Before, After, Memo) when is_map(Before), is_map(After) ->
ParentId = guild_thread_permissions:parent_id(Before),
case
guild_thread_permissions:parent_id(After) =:= ParentId andalso
- maps:get(<<"type">>, Before, undefined) =/= 12 andalso
- maps:get(<<"type">>, After, undefined) =/= 12
+ maps:get(<<"type">>, Before, undefined) =/= ?PRIVATE_THREAD andalso
+ maps:get(<<"type">>, After, undefined) =/= ?PRIVATE_THREAD
of
true -> Memo;
false -> #{}
@@ -182,6 +183,7 @@ shared_memo(_Before, _After, _Memo) ->
-spec unarchive_member_updates(integer(), map(), [session_pair()], guild_state(), map()) ->
[delivery()].
unarchive_member_updates(ThreadId, Thread, Viewers, #{id := GuildId} = State, Memo) ->
+ Wants = fun(Session, _Passive) -> is_member(Session, ThreadId, State) end,
case guild_thread_gate:store(State) of
undefined ->
[];
@@ -190,7 +192,7 @@ unarchive_member_updates(ThreadId, Thread, Viewers, #{id := GuildId} = State, Me
Thread,
Viewers,
State,
- fun(Session, _Passive) -> is_member(Session, ThreadId, State) end,
+ Wants,
Memo
),
[
@@ -228,7 +230,7 @@ thread_member_update(Data, State0) ->
ThreadId = snowflake_id:parse_maybe(maps:get(<<"id">>, Data, undefined)),
TargetId = snowflake_id:parse_maybe(maps:get(<<"user_id">>, Data, undefined)),
Thread = member_update_thread(ThreadId, TargetId, Data, State),
- Payload = guild_thread_gate:strip_internal(Data),
+ Payload = guild_thread_payload:strip_internal(Data),
Deliveries = [
{thread_member_update, Pid, Payload}
|| Thread =/= undefined,
@@ -336,7 +338,7 @@ synthesized_creates(Thread, ThreadId, Users, Viewers, State) ->
-spec members_update_payload(map(), guild_state()) -> map().
members_update_payload(Data, State) ->
- Base = guild_thread_gate:strip_internal(Data),
+ Base = guild_thread_payload:strip_internal(Data),
case maps:get(<<"added_members">>, Base, undefined) of
Added when is_list(Added) ->
Ctx = guild_member_list_connected:presence_context(State),
@@ -389,17 +391,10 @@ recipients(Thread, Viewers, State, Wants, Memo0) ->
Small = session_passive:is_small_guild(State),
{Pairs, Memo} = lists:foldl(
fun({_Sid, Session} = Pair, {Acc, Memo1}) ->
- case
- Wants(Session, (not Small) andalso session_passive:is_passive(GuildId, Session))
- of
- true ->
- case guild_thread_gate:thread_view_access(Session, Thread, State, Memo1) of
- {true, Memo2} -> {[Pair | Acc], Memo2};
- {false, Memo2} -> {Acc, Memo2}
- end;
- false ->
- {Acc, Memo1}
- end
+ Passive = (not Small) andalso session_passive:is_passive(GuildId, Session),
+ Candidate = Wants(Session, Passive) andalso Session,
+ {Ok, Memo2} = guild_thread_gate:thread_view_access(Candidate, Thread, State, Memo1),
+ {[Pair || Ok] ++ Acc, Memo2}
end,
{[], Memo0},
Viewers
@@ -415,8 +410,9 @@ joined_or_interested(ThreadId, State) ->
-spec interested(map(), integer(), guild_state()) -> boolean().
interested(Session, ThreadId, State) ->
- is_bot(Session) orelse is_member(Session, ThreadId, State) orelse
- maps:get(thread_subscribed, Session, false) =:= true.
+ type_conv:is_true(maps:get(bot, Session, false)) orelse
+ is_member(Session, ThreadId, State) orelse
+ type_conv:is_true(maps:get(thread_subscribed, Session, false)).
-spec is_member(map(), integer(), guild_state()) -> boolean().
is_member(#{user_id := UserId}, ThreadId, State) ->
@@ -427,10 +423,6 @@ is_member(#{user_id := UserId}, ThreadId, State) ->
is_member(_Session, _ThreadId, _State) ->
false.
--spec is_bot(map()) -> boolean().
-is_bot(Session) ->
- maps:get(bot, Session, false) =:= true.
-
-spec can_view(map(), map(), guild_state()) -> boolean().
can_view(#{user_id := UserId}, Thread, State) when is_integer(UserId) ->
Member = guild_permissions_check:find_member_by_user_id(UserId, State),
@@ -442,10 +434,10 @@ can_view(_Session, _Thread, _State) ->
viewer_sessions(State) ->
[
{Sid, Session}
- || {Sid, Session} <- maps:to_list(maps:get(sessions, State, #{})),
+ || {Sid, Session} <- maps:to_list(maps:get(sessions, State)),
is_map(Session),
guild_thread_gate:session_viewer(Session),
- maps:get(pending_connect, Session, false) =/= true,
+ not type_conv:is_true(maps:get(pending_connect, Session, false)),
is_pid(maps:get(pid, Session, undefined))
].
@@ -455,12 +447,11 @@ union(A, B) ->
-spec thread_or_context(integer(), map(), guild_state()) -> map() | undefined.
thread_or_context(ThreadId, Data, State) ->
- case guild_thread_gate:thread(ThreadId, State) of
- undefined ->
- case guild_state_threads:thread_context(ThreadId, Data) of
- undefined -> fallback_context(ThreadId, Data);
- Context -> Context
- end;
+ maybe
+ undefined ?= guild_thread_gate:thread(ThreadId, State),
+ undefined ?= guild_state_threads:thread_context(ThreadId, Data),
+ fallback_context(ThreadId, Data)
+ else
Thread ->
Thread
end.
@@ -476,19 +467,19 @@ fallback_context(_ThreadId, _Data) ->
-spec public_payload(map()) -> map().
public_payload(Data) ->
maps:without(
- [<<"member">>, <<"member_ids_preview">>], guild_thread_gate:strip_internal(Data)
+ [<<"member">>, <<"member_ids_preview">>], guild_thread_payload:strip_internal(Data)
).
-spec with_member(map(), integer(), term(), guild_state()) -> map().
with_member(Base, ThreadId, UserId, State) when is_integer(UserId) ->
- case guild_thread_gate:store(State) of
- undefined ->
- Base;
- Tab ->
- case guild_thread_store:get_member(Tab, ThreadId, UserId) of
- undefined -> Base;
- Member -> Base#{<<"member">> => Member}
- end
+ Member =
+ case guild_thread_gate:store(State) of
+ undefined -> undefined;
+ Tab -> guild_thread_store:get_member(Tab, ThreadId, UserId)
+ end,
+ case Member of
+ undefined -> Base;
+ _ -> Base#{<<"member">> => Member}
end;
with_member(Base, _ThreadId, _UserId, _State) ->
Base.
diff --git a/fluxer_gateway/src/guild/guild_thread_payload.erl b/fluxer_gateway/src/guild/guild_thread_payload.erl
new file mode 100644
index 000000000..3a04cab3e
--- /dev/null
+++ b/fluxer_gateway/src/guild/guild_thread_payload.erl
@@ -0,0 +1,146 @@
+%% SPDX-License-Identifier: AGPL-3.0-or-later
+
+-module(guild_thread_payload).
+-typing([eqwalizer]).
+
+-export([
+ mask_payload/2,
+ strip_channel_surface/1,
+ mask_role/1,
+ mask_overwrites/1,
+ strip_internal/1
+]).
+
+-define(THREAD_MESSAGE_FLAGS, 16#120).
+-define(THREAD_CREATED_MESSAGE, 18).
+-define(THREAD_PERMISSION_BITS,
+ (16#400000000 bor 16#800000000 bor 16#1000000000 bor 16#4000000000)
+).
+-define(SURFACE_KEYS, [
+ <<"thread_metadata">>,
+ <<"applied_tags">>,
+ <<"available_tags">>,
+ <<"default_auto_archive_duration">>,
+ <<"default_thread_rate_limit_per_user">>,
+ <<"default_reaction_emoji">>,
+ <<"default_sort_order">>,
+ <<"default_forum_layout">>,
+ <<"default_tag_setting">>,
+ <<"message_count">>,
+ <<"total_message_sent">>,
+ <<"member_ids_preview">>,
+ <<"member_count">>,
+ <<"flags">>
+]).
+
+-spec mask_payload(atom(), map()) -> map().
+mask_payload(Event, Data) when
+ Event =:= message_create; Event =:= message_update
+->
+ mask_message(Data);
+mask_payload(Event, Data) when
+ Event =:= channel_create; Event =:= channel_update
+->
+ mask_overwrites(strip_channel_surface(Data));
+mask_payload(channel_update_bulk, #{<<"channels">> := Channels} = Data) when
+ is_list(Channels)
+->
+ Data#{
+ <<"channels">> => [
+ mask_overwrites(strip_channel_surface(Channel))
+ || Channel <- Channels, is_map(Channel)
+ ]
+ };
+mask_payload(Event, #{<<"role">> := Role} = Data) when
+ is_map(Role), Event =:= guild_role_create; is_map(Role), Event =:= guild_role_update
+->
+ Data#{<<"role">> => mask_role(Role)};
+mask_payload(guild_role_update_bulk, #{<<"roles">> := Roles} = Data) when is_list(Roles) ->
+ Data#{<<"roles">> => [mask_role(Role) || Role <- Roles, is_map(Role)]};
+mask_payload(_Event, Data) ->
+ Data.
+
+-spec mask_message(map()) -> map().
+mask_message(Message) ->
+ Message1 = maps:remove(<<"thread">>, Message),
+ Message2 =
+ case maps:get(<<"flags">>, Message1, undefined) of
+ Flags when is_integer(Flags) ->
+ Message1#{<<"flags">> => Flags band bnot ?THREAD_MESSAGE_FLAGS};
+ _ ->
+ Message1
+ end,
+ Message3 =
+ case maps:get(<<"referenced_message">>, Message2, undefined) of
+ #{<<"type">> := ?THREAD_CREATED_MESSAGE} ->
+ Message2#{<<"referenced_message">> => null};
+ Referenced when is_map(Referenced) ->
+ Message2#{<<"referenced_message">> => mask_message(Referenced)};
+ _ ->
+ Message2
+ end,
+ case maps:get(<<"message_snapshots">>, Message3, undefined) of
+ Snapshots when is_list(Snapshots) ->
+ Message3#{<<"message_snapshots">> => [mask_snapshot(S) || S <- Snapshots]};
+ _ ->
+ Message3
+ end.
+
+-spec mask_snapshot(term()) -> term().
+mask_snapshot(#{<<"message">> := Message} = Snapshot) when is_map(Message) ->
+ Snapshot#{<<"message">> => mask_message(Message)};
+mask_snapshot(Snapshot) when is_map(Snapshot) ->
+ mask_message(Snapshot);
+mask_snapshot(Snapshot) ->
+ Snapshot.
+
+-spec strip_channel_surface(map()) -> map().
+strip_channel_surface(Channel) ->
+ maps:without(?SURFACE_KEYS, Channel).
+
+-spec mask_role(map()) -> map().
+mask_role(#{<<"permissions">> := Permissions} = Role) ->
+ Role#{<<"permissions">> => mask_bits(Permissions)};
+mask_role(Role) ->
+ Role.
+
+-spec mask_overwrites(map()) -> map().
+mask_overwrites(#{<<"permission_overwrites">> := Overwrites} = Channel) when
+ is_list(Overwrites)
+->
+ Channel#{<<"permission_overwrites">> => [mask_overwrite(O) || O <- Overwrites]};
+mask_overwrites(Channel) ->
+ Channel.
+
+-spec mask_overwrite(term()) -> term().
+mask_overwrite(Overwrite) when is_map(Overwrite) ->
+ maps:map(
+ fun
+ (<<"allow">>, Value) -> mask_bits(Value);
+ (<<"deny">>, Value) -> mask_bits(Value);
+ (_Key, Value) -> Value
+ end,
+ Overwrite
+ );
+mask_overwrite(Overwrite) ->
+ Overwrite.
+
+-spec mask_bits(term()) -> term().
+mask_bits(Value) when is_integer(Value) ->
+ Value band bnot ?THREAD_PERMISSION_BITS;
+mask_bits(Value) when is_binary(Value) ->
+ case bitset:parse_optional(Value) of
+ Bits when is_integer(Bits) -> integer_to_binary(Bits band bnot ?THREAD_PERMISSION_BITS);
+ _ -> Value
+ end;
+mask_bits(Value) ->
+ Value.
+
+-spec strip_internal(map()) -> map().
+strip_internal(Data) ->
+ maps:filter(fun(Key, _Value) -> not internal_key(Key) end, Data).
+
+-spec internal_key(term()) -> boolean().
+internal_key(<<"_fluxer_", _/binary>>) -> true;
+internal_key(<<"__thread_", _/binary>>) -> true;
+internal_key(_) -> false.
diff --git a/fluxer_gateway/src/guild/guild_thread_view.erl b/fluxer_gateway/src/guild/guild_thread_view.erl
index 7bdb3011c..d7488b6d1 100644
--- a/fluxer_gateway/src/guild/guild_thread_view.erl
+++ b/fluxer_gateway/src/guild/guild_thread_view.erl
@@ -11,43 +11,31 @@
hide_for_non_viewer/4
]).
--type guild_state() :: map().
-
--spec guild_threads(integer(), map(), map() | undefined, guild_state()) -> [map()].
+-spec guild_threads(integer(), map(), map() | undefined, map()) -> [map()].
guild_threads(UserId, Opts, Member, State) ->
- case guild_thread_gate:store(State) of
- undefined ->
- [];
- Tab ->
- case maps:get(bot, Opts, false) of
- true -> bot_threads(UserId, Member, Tab, State);
- false -> joined_threads(UserId, Member, Tab, State)
- end
+ case {guild_thread_gate:store(State), maps:get(bot, Opts, false)} of
+ {undefined, _Bot} -> [];
+ {Tab, true} -> bot_threads(UserId, Member, Tab, State);
+ {Tab, false} -> joined_threads(UserId, Member, Tab, State);
+ {_Tab, Bot} -> error({case_clause, Bot})
end.
--spec bot_threads(integer(), map() | undefined, ets:table(), guild_state()) -> [map()].
+-spec bot_threads(integer(), map() | undefined, ets:table(), map()) -> [map()].
bot_threads(UserId, Member, Tab, State) ->
[
with_own_member(UserId, Thread, Tab)
|| Thread <- guild_thread_store:threads(Tab), can_view(UserId, Thread, Member, State)
].
--spec joined_threads(integer(), map() | undefined, ets:table(), guild_state()) -> [map()].
+-spec joined_threads(integer(), map() | undefined, ets:table(), map()) -> [map()].
joined_threads(UserId, Member, Tab, State) ->
- lists:filtermap(
- fun(ThreadId) ->
- case guild_thread_store:get_thread(Tab, ThreadId) of
- undefined ->
- false;
- Thread ->
- case can_view(UserId, Thread, Member, State) of
- true -> {true, with_own_member(UserId, Thread, Tab)};
- false -> false
- end
- end
- end,
- guild_thread_store:user_thread_ids(Tab, UserId)
- ).
+ [
+ with_own_member(UserId, Thread, Tab)
+ || ThreadId <- guild_thread_store:user_thread_ids(Tab, UserId),
+ Thread <- [guild_thread_store:get_thread(Tab, ThreadId)],
+ Thread =/= undefined,
+ can_view(UserId, Thread, Member, State)
+ ].
-spec with_own_member(integer(), map(), ets:table()) -> map().
with_own_member(UserId, Thread, Tab) ->
@@ -69,13 +57,13 @@ thread_payload(Thread) ->
thread_id(Thread) ->
snowflake_id:parse(maps:get(<<"id">>, Thread)).
--spec can_view(integer(), map(), map() | undefined, guild_state()) -> boolean().
+-spec can_view(integer(), map(), map() | undefined, map()) -> boolean().
can_view(UserId, Thread, Member, State) ->
Perms = guild_thread_permissions:resolve(UserId, Thread, Member, State),
bitset:has(Perms, constants:view_channel_permission()).
-spec viewable_thread_ids(
- integer(), [integer()] | all | joined, map() | undefined, guild_state()
+ integer(), [integer()] | all | joined, map() | undefined, map()
) ->
[{integer(), map()}].
viewable_thread_ids(UserId, Parents, Member, State) ->
@@ -102,34 +90,27 @@ candidate_threads(Parents, _UserId, Tab) ->
-spec stored_threads([integer()], ets:table()) -> [map()].
stored_threads(ThreadIds, Tab) ->
- lists:filtermap(
- fun(ThreadId) ->
- case guild_thread_store:get_thread(Tab, ThreadId) of
- undefined -> false;
- Thread -> {true, Thread}
- end
- end,
- ThreadIds
- ).
+ [
+ Thread
+ || ThreadId <- ThreadIds,
+ Thread <- [guild_thread_store:get_thread(Tab, ThreadId)],
+ Thread =/= undefined
+ ].
-spec list_sync(
- integer(), integer(), [integer()] | all | joined, map() | undefined, guild_state()
+ integer(), integer(), [integer()] | all | joined, map() | undefined, map()
) ->
map().
list_sync(GuildId, UserId, Parents, Member, State) ->
Viewable = viewable_thread_ids(UserId, Parents, Member, State),
- Members =
- case guild_thread_gate:store(State) of
- undefined ->
- [];
- Tab ->
- [
- M
- || {ThreadId, _Thread} <- Viewable,
- M <- [guild_thread_store:get_member(Tab, ThreadId, UserId)],
- M =/= undefined
- ]
- end,
+ Tab = guild_thread_gate:store(State),
+ Members = [
+ M
+ || {ThreadId, _Thread} <- Viewable,
+ Tab =/= undefined,
+ M <- [guild_thread_store:get_member(Tab, ThreadId, UserId)],
+ M =/= undefined
+ ],
Base = #{
<<"guild_id">> => integer_to_binary(GuildId),
<<"threads">> => [thread_payload(Thread) || {_Id, Thread} <- Viewable],
@@ -141,43 +122,39 @@ list_sync(GuildId, UserId, Parents, Member, State) ->
_ -> Base#{<<"channel_ids">> => [integer_to_binary(P) || P <- Parents]}
end.
--spec hide_for_non_viewer(integer(), map() | undefined, guild_state(), [map()]) -> [map()].
+-spec hide_for_non_viewer(integer(), map() | undefined, map(), [map()]) -> [map()].
hide_for_non_viewer(UserId, Member, State, Channels) ->
- Kept = [C || C <- Channels, not guild_thread_gate:is_thread_only_type(channel_type(C))],
+ Kept = [C || C <- Channels, not channel_types:is_thread_only(channel_type(C))],
Visible =
case length(Kept) =:= length(Channels) of
true -> Kept;
false -> drop_forum_only_categories(UserId, Member, State, Kept)
end,
[
- guild_thread_gate:mask_overwrites(guild_thread_gate:strip_channel_surface(C))
+ guild_thread_payload:mask_overwrites(guild_thread_payload:strip_channel_surface(C))
|| C <- Visible
].
--spec drop_forum_only_categories(integer(), map() | undefined, guild_state(), [map()]) ->
+-spec drop_forum_only_categories(integer(), map() | undefined, map(), [map()]) ->
[map()].
drop_forum_only_categories(UserId, Member, State, Channels) ->
Parents = sets:from_list([
P
|| C <- Channels,
- channel_type(C) =/= 4,
+ not channel_types:is_category(channel_type(C)),
P <- [snowflake_id:parse_maybe(maps:get(<<"parent_id">>, C, undefined))],
is_integer(P)
]),
lists:filter(
fun(C) ->
- case
- {channel_type(C), snowflake_id:parse_maybe(maps:get(<<"id">>, C, undefined))}
- of
- {4, Id} when is_integer(Id) ->
- sets:is_element(Id, Parents) orelse
- guild_permissions_check:can_view_channel_by_permissions(
- UserId, Id, Member, State
- ) orelse
- guild_virtual_channel_access:has_virtual_access(UserId, Id, State);
- _ ->
- true
- end
+ Type = channel_type(C),
+ Id = snowflake_id:parse_maybe(maps:get(<<"id">>, C, undefined)),
+ not channel_types:is_category(Type) orelse not is_integer(Id) orelse
+ sets:is_element(Id, Parents) orelse
+ guild_permissions_check:can_view_channel_by_permissions(
+ UserId, Id, Member, State
+ ) orelse
+ guild_virtual_channel_access:has_virtual_access(UserId, Id, State)
end,
Channels
).
diff --git a/fluxer_gateway/src/guild/guild_visibility_roles.erl b/fluxer_gateway/src/guild/guild_visibility_roles.erl
index 86c2a4c6e..41c7e18c6 100644
--- a/fluxer_gateway/src/guild/guild_visibility_roles.erl
+++ b/fluxer_gateway/src/guild/guild_visibility_roles.erl
@@ -11,15 +11,11 @@
can_send_member_list/3
]).
--export_type([guild_state/0, user_id/0, channel_id/0]).
-
-type guild_state() :: map().
-type user_id() :: integer().
-type channel_id() :: integer().
--spec maybe_ensure_parent_category_visible(
- channel_id(), map(), guild_state(), map(), integer()
-) -> map().
+-spec maybe_ensure_parent_category_visible(integer(), map(), map(), map(), integer()) -> map().
maybe_ensure_parent_category_visible(ChannelId, ViewableMap, State, SessionData, GuildId) ->
case
{snowflake_id(GuildId), guild_permissions_check:find_channel_by_id(ChannelId, State)}
@@ -54,7 +50,7 @@ ensure_parent_category_visible(
ensure_parent_category_visible(_ParentId, ViewableMap, _State, _SessionData, _GuildId) ->
ViewableMap.
--spec dispatch_channel_delete(channel_id(), pid(), guild_state(), integer()) -> ok.
+-spec dispatch_channel_delete(integer(), pid(), map(), integer()) -> ok.
dispatch_channel_delete(ChannelId, SessionPid, OldState, GuildId) ->
case {is_pid(SessionPid), snowflake_id(ChannelId), snowflake_id(GuildId)} of
{true, ResolvedChannelId, ResolvedGuildId} when
@@ -67,7 +63,7 @@ dispatch_channel_delete(ChannelId, SessionPid, OldState, GuildId) ->
ok
end.
--spec dispatch_channel_create(channel_id(), map(), guild_state(), integer()) -> ok.
+-spec dispatch_channel_create(integer(), map(), map(), integer()) -> ok.
dispatch_channel_create(ChannelId, SessionData, NewState, GuildId) ->
case
{maps:get(pid, SessionData, undefined), snowflake_id(ChannelId), snowflake_id(GuildId)}
@@ -82,7 +78,7 @@ dispatch_channel_create(ChannelId, SessionData, NewState, GuildId) ->
ok
end.
--spec send_member_list_sync(binary(), map(), channel_id(), integer(), guild_state()) -> ok.
+-spec send_member_list_sync(binary(), map(), integer(), integer(), map()) -> ok.
send_member_list_sync(SessionId, SessionData, ChannelId, GuildId, State) ->
SessionPid = maps:get(pid, SessionData),
case {is_pid(SessionPid), snowflake_id(ChannelId), snowflake_id(GuildId)} of
@@ -144,7 +140,7 @@ maybe_dispatch_sync(SessionUserId, SessionPid, ChannelId, GuildId, ListId, Range
ok
end.
--spec can_send_member_list(user_id() | undefined, channel_id(), guild_state()) -> boolean().
+-spec can_send_member_list(integer() | undefined, integer(), map()) -> boolean().
can_send_member_list(UserId, ChannelId, State) ->
case snowflake_id(ChannelId) of
ResolvedChannelId when is_integer(UserId), is_integer(ResolvedChannelId) ->
@@ -188,7 +184,9 @@ session_channel(Channel, SessionData, State) ->
not guild_thread_gate:session_viewer(SessionData)
of
true ->
- guild_thread_gate:mask_overwrites(guild_thread_gate:strip_channel_surface(Channel));
+ guild_thread_payload:mask_overwrites(
+ guild_thread_payload:strip_channel_surface(Channel)
+ );
false ->
Channel
end.