A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
feat(gateway): build visitor permissions and snapshots
Hampuscd79bc98837a
diff --git a/fluxer_gateway/src/guild/guild_visitor_permissions.erl b/fluxer_gateway/src/guild/guild_visitor_permissions.erlnew file mode 100644index 000000000..be4cb1ac2--- /dev/null+++ b/fluxer_gateway/src/guild/guild_visitor_permissions.erl@@ -0,0 +1,198 @@+%% SPDX-License-Identifier: AGPL-3.0-or-later++-module(guild_visitor_permissions).+-typing([eqwalizer]).++-export([+ viewable_channel_map/2,+ strip_overwrites/2,+ guild_nsfw/1+]).++-define(AGE_RESTRICTED_LEVEL, 3).++-type context() :: #{+ guild_id := integer(),+ everyone := non_neg_integer(),+ guild_nsfw := boolean(),+ adult := boolean()+}.++-spec mask() -> non_neg_integer().+mask() ->+ constants:view_channel_permission() bor constants:read_message_history_permission().++-spec context(map(), boolean()) -> context().+context(#{id := GuildId} = State, Adult) when is_integer(GuildId) ->+ Data = guild_data_index:ensure_data_map(State),+ #{+ guild_id => GuildId,+ everyone => everyone_permissions(Data, GuildId),+ guild_nsfw => guild_nsfw(Data),+ adult => Adult+ }.++-spec can_view(context(), map(), map() | undefined) -> boolean().+can_view(Context, Channel, Parent) ->+ not hidden_nsfw(Context, Channel, Parent) andalso+ bitset:has(visible_permissions(Context, Channel), constants:view_channel_permission()).++-spec viewable_channel_map(map(), boolean()) -> #{integer() => true}.+viewable_channel_map(State, Adult) ->+ Data = guild_data_index:ensure_data_map(State),+ Context = context(State, Adult),+ Index = guild_data_index_channels:channel_index(Data),+ lists:foldl(+ fun(Channel, Acc) -> add_viewable(Channel, Index, Context, Acc) end,+ #{},+ map_utils:ensure_list(guild_data_index_channels:channel_list(Data))+ ).++-spec strip_overwrites(map(), integer()) -> map().+strip_overwrites(Channel, GuildId) ->+ case maps:get(<<"permission_overwrites">>, Channel, undefined) of+ Overwrites when is_list(Overwrites) ->+ Channel#{+ <<"permission_overwrites">> => [+ Overwrite+ || Overwrite <- Overwrites, overwrite_id(Overwrite) =:= GuildId+ ]+ };+ _ ->+ Channel+ end.++-spec guild_nsfw(map()) -> boolean().+guild_nsfw(Data) ->+ Guild = map_utils:ensure_map(maps:get(<<"guild">>, Data, #{})),+ case maps:get(<<"nsfw">>, Guild, undefined) of+ true -> true;+ false -> false;+ _ -> maps:get(<<"nsfw_level">>, Guild, 0) =:= ?AGE_RESTRICTED_LEVEL+ end.++-spec everyone_permissions(map(), integer()) -> non_neg_integer().+everyone_permissions(Data, GuildId) ->+ lists:foldl(+ fun(Role, Acc) -> everyone_role_permissions(Role, GuildId, Acc) end,+ 0,+ map_utils:ensure_list(maps:get(<<"roles">>, Data, []))+ ).++-spec everyone_role_permissions(term(), integer(), non_neg_integer()) -> non_neg_integer().+everyone_role_permissions(Role, GuildId, Acc) when is_map(Role) ->+ case snowflake_id:parse_optional(maps:get(<<"id">>, Role, undefined)) of+ GuildId -> parse_bits(maps:get(<<"permissions">>, Role, 0));+ _ -> Acc+ end;+everyone_role_permissions(_Role, _GuildId, Acc) ->+ Acc.++-spec add_viewable(term(), map(), context(), #{integer() => true}) -> #{integer() => true}.+add_viewable(Channel, Index, Context, Acc) when is_map(Channel) ->+ ChannelId = snowflake_id:parse_optional(maps:get(<<"id">>, Channel, undefined)),+ case+ is_integer(ChannelId) andalso can_view(Context, Channel, parent_channel(Channel, Index))+ of+ true when is_integer(ChannelId) -> Acc#{ChannelId => true};+ false -> Acc+ end;+add_viewable(_Channel, _Index, _Context, Acc) ->+ Acc.++-spec parent_channel(map(), map()) -> map() | undefined.+parent_channel(Channel, Index) ->+ ParentId = snowflake_id:parse_optional(maps:get(<<"parent_id">>, Channel, undefined)),+ case Index of+ #{ParentId := Parent} when is_integer(ParentId), is_map(Parent) ->+ Parent;+ _ ->+ undefined+ end.++-spec hidden_nsfw(context(), map(), map() | undefined) -> boolean().+hidden_nsfw(#{adult := true}, _Channel, _Parent) ->+ false;+hidden_nsfw(#{guild_nsfw := GuildNsfw}, Channel, Parent) ->+ effective_nsfw(Channel, Parent, GuildNsfw).++-spec effective_nsfw(map(), map() | undefined, boolean()) -> boolean().+effective_nsfw(Channel, Parent, GuildNsfw) ->+ case nsfw_override(Channel) of+ Value when is_boolean(Value) -> Value;+ undefined -> inherited_nsfw(Channel, Parent, GuildNsfw)+ end.++-spec inherited_nsfw(map(), map() | undefined, boolean()) -> boolean().+inherited_nsfw(Channel, Parent, GuildNsfw) ->+ IsCategory = channel_types:is_category(+ map_utils:get_integer(Channel, <<"type">>, undefined)+ ),+ ParentOverride =+ case {IsCategory, Parent} of+ {false, ParentMap} when is_map(ParentMap) -> nsfw_override(ParentMap);+ _ -> undefined+ end,+ case ParentOverride of+ undefined -> GuildNsfw;+ Value -> Value+ end.++-spec nsfw_override(map()) -> boolean() | undefined.+nsfw_override(Channel) ->+ case maps:find(<<"nsfw_override">>, Channel) of+ {ok, Value} when is_boolean(Value) -> Value;+ {ok, _} -> undefined;+ error -> legacy_nsfw(Channel)+ end.++-spec legacy_nsfw(map()) -> boolean() | undefined.+legacy_nsfw(Channel) ->+ case maps:get(<<"nsfw">>, Channel, undefined) of+ Value when is_boolean(Value) -> Value;+ _ -> undefined+ end.++-spec visible_permissions(context(), map()) -> non_neg_integer().+visible_permissions(#{guild_id := GuildId, everyone := Everyone}, Channel) ->+ Base = Everyone band (bnot constants:administrator_permission()),+ Overwrites = map_utils:ensure_list(maps:get(<<"permission_overwrites">>, Channel, [])),+ Applied = lists:foldl(+ fun(Overwrite, Acc) -> apply_everyone_overwrite(Overwrite, GuildId, Acc) end,+ Base,+ Overwrites+ ),+ Applied band mask().++-spec apply_everyone_overwrite(term(), integer(), non_neg_integer()) -> non_neg_integer().+apply_everyone_overwrite(Overwrite, GuildId, Acc) when is_map(Overwrite) ->+ case {overwrite_type(Overwrite), overwrite_id(Overwrite)} of+ {0, GuildId} ->+ Allow = parse_bits(maps:get(<<"allow">>, Overwrite, 0)),+ Deny = parse_bits(maps:get(<<"deny">>, Overwrite, 0)),+ (Acc band (bnot Deny)) bor Allow;+ _ ->+ Acc+ end;+apply_everyone_overwrite(_Overwrite, _GuildId, Acc) ->+ Acc.++-spec overwrite_type(map()) -> integer() | undefined.+overwrite_type(Overwrite) ->+ case map_utils:get_integer(Overwrite, <<"type">>, undefined) of+ Type when is_integer(Type) -> Type;+ _ -> undefined+ end.++-spec overwrite_id(term()) -> integer() | undefined.+overwrite_id(Overwrite) when is_map(Overwrite) ->+ snowflake_id:parse_optional(maps:get(<<"id">>, Overwrite, undefined));+overwrite_id(_) ->+ undefined.++-spec parse_bits(term()) -> non_neg_integer().+parse_bits(Value) ->+ case bitset:parse_maybe(Value) of+ Bits when is_integer(Bits), Bits >= 0 -> Bits;+ _ -> 0+ end.diff --git a/fluxer_gateway/src/guild/guild_visitor_snapshot.erl b/fluxer_gateway/src/guild/guild_visitor_snapshot.erlnew file mode 100644index 000000000..6196c870c--- /dev/null+++ b/fluxer_gateway/src/guild/guild_visitor_snapshot.erl@@ -0,0 +1,155 @@+%% SPDX-License-Identifier: AGPL-3.0-or-later++-module(guild_visitor_snapshot).+-typing([eqwalizer]).++-export([view/2, build/2]).++-define(MAX_SNAPSHOT_THREADS, 200).++-type visibility() :: #{adult := boolean(), thread_viewer := boolean(), atom() => term()}.++-spec view(+ #{adult := boolean(), thread_viewer := boolean(), atom() => term()},+ guild_data:guild_state()+) ->+ {#{integer() => true}, guild_data:guild_state()}.+view(#{adult := Adult, thread_viewer := Viewer} = Visibility, State) ->+ Visitors = guild_visitor_state:get(State),+ Views = maps:get(views, Visitors),+ Key = {Adult, Viewer},+ case maps:get(Key, Views, undefined) of+ View when is_map(View) ->+ {View, State};+ _ ->+ View = compute_view(Visibility, State),+ {View, guild_visitor_state:put(Visitors#{views => Views#{Key => View}}, State)}+ end.++-spec compute_view(visibility(), guild_data:guild_state()) -> #{integer() => true}.+compute_view(#{adult := Adult, thread_viewer := Viewer}, State) ->+ Full = guild_visitor_permissions:viewable_channel_map(State, Adult),+ case Viewer orelse not guild_thread_gate:needs_variant(State) of+ true ->+ Full;+ false ->+ Index = guild_data_index_channels:channel_index(+ guild_data_index:ensure_data_map(State)+ ),+ Hidden = [+ ChannelId+ || ChannelId <- maps:keys(Full),+ thread_only_channel(maps:get(ChannelId, Index, #{}))+ ],+ maps:without(Hidden, Full)+ end.++-spec thread_only_channel(term()) -> boolean().+thread_only_channel(Channel) when is_map(Channel) ->+ channel_types:is_thread_only(+ map_utils:get_integer(Channel, <<"type">>, undefined)+ );+thread_only_channel(_) ->+ false.++-spec build(guild_visitors:visitor_session(), guild_data:guild_state()) -> map().+build(Session, State) ->+ Data = guild_data_index:ensure_data_map(State),+ GuildId = maps:get(id, State),+ View = maps:get(viewable_channels, Session),+ Viewer = maps:get(thread_viewer, Session),+ AllChannels = map_utils:ensure_list(guild_data_channels:channels_from_data(Data)),+ Visible = [C || C <- AllChannels, maps:is_key(channel_id(C), View)],+ Channels = [+ mask_channel(Session, guild_visitor_permissions:strip_overwrites(C, GuildId), State)+ || C <- with_parents(Visible, AllChannels)+ ],+ Roles = [+ mask_role(Session, R, State)+ || R <- map_utils:ensure_list(maps:get(<<"roles">>, Data, []))+ ],+ Base = #{+ <<"id">> => integer_to_binary(GuildId),+ <<"properties">> => maps:get(<<"guild">>, Data, #{}),+ <<"roles">> => Roles,+ <<"channels">> => Channels,+ <<"emojis">> => maps:get(<<"emojis">>, Data, []),+ <<"stickers">> => maps:get(<<"stickers">>, Data, []),+ <<"members">> => [],+ <<"member_count">> => maps:get(+ member_count, State, guild_data_index_members:member_count(Data)+ ),+ <<"online_count">> => guild_member_list_read:get_online_count(State),+ <<"presences">> => [],+ <<"voice_states">> => [],+ <<"joined_at">> => null,+ <<"visiting">> => true+ },+ case Viewer andalso guild_thread_gate:active(State) of+ true -> Base#{<<"threads">> => visitor_threads(View, State)};+ false -> Base+ end.++-spec visitor_threads(#{integer() => true}, guild_data:guild_state()) -> [map()].+visitor_threads(View, State) ->+ Threads =+ case guild_thread_gate:store(State) of+ undefined -> [];+ Tab -> guild_thread_store:threads(Tab)+ end,+ Visible = [+ guild_thread_view:thread_payload(Thread)+ || Thread <- Threads, public_thread_in_view(Thread, View)+ ],+ Sorted = lists:sort(fun(A, B) -> channel_id(A) >= channel_id(B) end, Visible),+ lists:sublist(Sorted, ?MAX_SNAPSHOT_THREADS).++-spec public_thread_in_view(map(), #{integer() => true}) -> boolean().+public_thread_in_view(Thread, View) ->+ channel_types:is_public_thread(map_utils:get_integer(Thread, <<"type">>, undefined)) andalso+ maps:is_key(parent_id(Thread), View).++-spec mask_channel(visibility(), map(), guild_data:guild_state()) -> map().+mask_channel(#{thread_viewer := true}, Channel, _State) ->+ Channel;+mask_channel(#{thread_viewer := false}, Channel, State) ->+ case guild_thread_gate:needs_variant(State) of+ true ->+ guild_thread_payload:mask_overwrites(+ guild_thread_payload:strip_channel_surface(Channel)+ );+ false ->+ Channel+ end.++-spec mask_role(visibility(), term(), guild_data:guild_state()) -> term().+mask_role(#{thread_viewer := false}, Role, State) when is_map(Role) ->+ case guild_thread_gate:needs_variant(State) of+ true -> guild_thread_payload:mask_role(Role);+ false -> Role+ end;+mask_role(_Visibility, Role, _State) ->+ Role.++-spec with_parents([map()], [map()]) -> [map()].+with_parents(Visible, All) ->+ Ids = maps:from_keys([channel_id(C) || C <- Visible], true),+ Missing = lists:usort([+ P+ || C <- Visible,+ P <- [parent_id(C)],+ is_integer(P),+ not maps:is_key(P, Ids)+ ]),+ Extra = [C || C <- All, lists:member(channel_id(C), Missing)],+ Visible ++ Extra.++-spec channel_id(term()) -> integer() | undefined.+channel_id(Channel) when is_map(Channel) ->+ snowflake_id:parse_maybe(maps:get(<<"id">>, Channel, undefined));+channel_id(_) ->+ undefined.++-spec parent_id(map()) -> integer() | undefined.+parent_id(Channel) ->+ snowflake_id:parse_maybe(maps:get(<<"parent_id">>, Channel, undefined)).