mirror of
https://framagit.org/framasoft/mobilizon.git
synced 2024-12-23 08:22:50 +00:00
b0e8a32d2a
Signed-off-by: Thomas Citharel <tcit@tcit.fr>
177 lines
5.2 KiB
Elixir
177 lines
5.2 KiB
Elixir
defmodule Mobilizon.Service.Export.Feed do
|
|
@moduledoc """
|
|
Serve Atom Syndication Feeds.
|
|
"""
|
|
|
|
import Mobilizon.Web.Gettext
|
|
|
|
alias Atomex.{Entry, Feed}
|
|
|
|
alias Mobilizon.{Actors, Events, Users}
|
|
alias Mobilizon.Actors.Actor
|
|
alias Mobilizon.Events.{Event, FeedToken}
|
|
alias Mobilizon.Storage.Page
|
|
alias Mobilizon.Users.User
|
|
|
|
alias Mobilizon.Web.{Endpoint, MediaProxy}
|
|
alias Mobilizon.Web.Router.Helpers, as: Routes
|
|
|
|
require Logger
|
|
|
|
@version Mix.Project.config()[:version]
|
|
def version, do: @version
|
|
|
|
@spec create_cache(String.t()) :: {:commit, String.t()} | {:ignore, any()}
|
|
def create_cache("actor_" <> name) do
|
|
case fetch_actor_event_feed(name) do
|
|
{:ok, res} ->
|
|
{:commit, res}
|
|
|
|
err ->
|
|
{:ignore, err}
|
|
end
|
|
end
|
|
|
|
@spec create_cache(String.t()) :: {:commit, String.t()} | {:ignore, any()}
|
|
def create_cache("token_" <> token) do
|
|
case fetch_events_from_token(token) do
|
|
{:ok, res} ->
|
|
{:commit, res}
|
|
|
|
err ->
|
|
{:ignore, err}
|
|
end
|
|
end
|
|
|
|
@spec fetch_actor_event_feed(String.t()) :: String.t()
|
|
defp fetch_actor_event_feed(name) do
|
|
with %Actor{} = actor <- Actors.get_local_actor_by_name(name),
|
|
{:visibility, true} <- {:visibility, Actor.is_public_visibility?(actor)},
|
|
%Page{elements: events} <- Events.list_public_events_for_actor(actor) do
|
|
{:ok, build_actor_feed(actor, events)}
|
|
else
|
|
err ->
|
|
{:error, err}
|
|
end
|
|
end
|
|
|
|
# Build an atom feed from actor and its public events
|
|
@spec build_actor_feed(Actor.t(), list(), boolean()) :: String.t()
|
|
defp build_actor_feed(%Actor{} = actor, events, public \\ true) do
|
|
display_name = Actor.display_name(actor)
|
|
|
|
self_url =
|
|
Endpoint
|
|
|> Routes.feed_url(:actor, actor.preferred_username, "atom")
|
|
|> URI.decode()
|
|
|
|
title =
|
|
if public,
|
|
do: "%{actor}'s public events feed on Mobilizon",
|
|
else: "%{actor}'s private events feed on Mobilizon"
|
|
|
|
# Title uses default instance language
|
|
feed =
|
|
self_url
|
|
|> Feed.new(
|
|
DateTime.utc_now(),
|
|
Gettext.gettext(Mobilizon.Web.Gettext, title, actor: display_name)
|
|
)
|
|
|> Feed.author(display_name, uri: actor.url)
|
|
|> Feed.link(self_url, rel: "self")
|
|
|> Feed.link(actor.url, rel: "alternate")
|
|
|> Feed.generator("Mobilizon", uri: "https://joinmobilizon.org", version: version())
|
|
|> Feed.entries(Enum.map(events, &get_entry/1))
|
|
|
|
feed =
|
|
if actor.avatar do
|
|
feed |> Feed.icon(actor.avatar.url |> MediaProxy.url())
|
|
else
|
|
feed
|
|
end
|
|
|
|
feed =
|
|
if actor.banner do
|
|
feed |> Feed.logo(actor.banner.url |> MediaProxy.url())
|
|
else
|
|
feed
|
|
end
|
|
|
|
feed
|
|
|> Feed.build()
|
|
|> Atomex.generate_document()
|
|
end
|
|
|
|
# Create an entry for the Atom feed
|
|
@spec get_entry(Event.t()) :: any()
|
|
defp get_entry(%Event{} = event) do
|
|
description = event.description || ""
|
|
|
|
entry =
|
|
event.url
|
|
|> Entry.new(event.publish_at || event.inserted_at, event.title)
|
|
|> Entry.link(event.url, rel: "alternate", type: "text/html")
|
|
|> Entry.content({:cdata, description}, type: "html")
|
|
|> Entry.published(event.publish_at || event.inserted_at)
|
|
|
|
# Add tags
|
|
entry =
|
|
event.tags
|
|
|> Enum.uniq()
|
|
|> Enum.reduce(entry, fn tag, acc -> Entry.category(acc, tag.slug, label: tag.title) end)
|
|
|
|
Entry.build(entry)
|
|
end
|
|
|
|
@spec fetch_events_from_token(String.t()) :: String.t()
|
|
defp fetch_events_from_token(token) do
|
|
with {:ok, _uuid} <- Ecto.UUID.cast(token),
|
|
%FeedToken{actor: actor, user: %User{} = user} <- Events.get_feed_token(token) do
|
|
case actor do
|
|
%Actor{} = actor ->
|
|
events = actor |> fetch_identity_participations() |> participations_to_events()
|
|
{:ok, build_actor_feed(actor, events, false)}
|
|
|
|
nil ->
|
|
with actors <- Users.get_actors_for_user(user),
|
|
events <-
|
|
actors
|
|
|> Enum.map(fn actor ->
|
|
actor
|
|
|> Events.list_event_participations_for_actor()
|
|
|> participations_to_events()
|
|
end)
|
|
|> Enum.concat() do
|
|
{:ok, build_user_feed(events, user, token)}
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
defp fetch_identity_participations(%Actor{} = actor) do
|
|
with %Page{} = page <- Events.list_event_participations_for_actor(actor) do
|
|
page
|
|
end
|
|
end
|
|
|
|
defp participations_to_events(%Page{elements: participations}) do
|
|
participations
|
|
|> Enum.map(& &1.event_id)
|
|
|> Enum.map(&Events.get_event_with_preload!/1)
|
|
end
|
|
|
|
# Build an atom feed from actor and its public events
|
|
@spec build_user_feed(list(), User.t(), String.t()) :: String.t()
|
|
defp build_user_feed(events, %User{email: email}, token) do
|
|
self_url = Endpoint |> Routes.feed_url(:going, token, "atom") |> URI.decode()
|
|
|
|
# Title uses default instance language
|
|
self_url
|
|
|> Feed.new(DateTime.utc_now(), gettext("Feed for %{email} on Mobilizon", email: email))
|
|
|> Feed.link(self_url, rel: "self")
|
|
|> Feed.generator("Mobilizon", uri: "https://joinmobilizon.org", version: version())
|
|
|> Feed.entries(Enum.map(events, &get_entry/1))
|
|
|> Feed.build()
|
|
|> Atomex.generate_document()
|
|
end
|
|
end
|