Rename MobilizonWeb to Mobilizon.Web

lib/web/controllers/activity_pub_controller.ex

@@ -0,0 +1,140 @@
+# Portions of this file are derived from Pleroma:
+# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social>
+# SPDX-License-Identifier: AGPL-3.0-only
+# Upstream: https://git.pleroma.social/pleroma/pleroma/blob/develop/lib/pleroma/web/activity_pub/activity_pub_controller.ex
+
+defmodule Mobilizon.Web.ActivityPubController do
+  use Mobilizon.Web, :controller
+
+  alias Mobilizon.{Actors, Config}
+  alias Mobilizon.Actors.Actor
+
+  alias Mobilizon.Federation.ActivityPub
+  alias Mobilizon.Federation.ActivityPub.Federator
+
+  alias Mobilizon.Web.ActivityPub.ActorView
+  alias Mobilizon.Web.Cache
+
+  require Logger
+
+  action_fallback(:errors)
+
+  plug(Mobilizon.Web.Plugs.Federating when action in [:inbox, :relay])
+  plug(:relay_active? when action in [:relay])
+
+  def relay_active?(conn, _) do
+    if Config.get([:instance, :allow_relay]) do
+      conn
+    else
+      conn
+      |> put_status(404)
+      |> json("Not found")
+      |> halt()
+    end
+  end
+
+  def following(conn, %{"name" => name, "page" => page}) do
+    with {page, ""} <- Integer.parse(page),
+         %Actor{} = actor <- Actors.get_local_actor_by_name_with_preload(name) do
+      conn
+      |> put_resp_header("content-type", "application/activity+json")
+      |> json(ActorView.render("following.json", %{actor: actor, page: page}))
+    end
+  end
+
+  def following(conn, %{"name" => name}) do
+    with %Actor{} = actor <- Actors.get_local_actor_by_name_with_preload(name) do
+      conn
+      |> put_resp_header("content-type", "application/activity+json")
+      |> json(ActorView.render("following.json", %{actor: actor}))
+    end
+  end
+
+  def followers(conn, %{"name" => name, "page" => page}) do
+    with {page, ""} <- Integer.parse(page),
+         %Actor{} = actor <- Actors.get_local_actor_by_name_with_preload(name) do
+      conn
+      |> put_resp_header("content-type", "application/activity+json")
+      |> json(ActorView.render("followers.json", %{actor: actor, page: page}))
+    end
+  end
+
+  def followers(conn, %{"name" => name}) do
+    with %Actor{} = actor <- Actors.get_local_actor_by_name_with_preload(name) do
+      conn
+      |> put_resp_header("content-type", "application/activity+json")
+      |> json(ActorView.render("followers.json", %{actor: actor}))
+    end
+  end
+
+  def outbox(conn, %{"name" => name, "page" => page}) do
+    with {page, ""} <- Integer.parse(page),
+         %Actor{} = actor <- Actors.get_local_actor_by_name(name) do
+      conn
+      |> put_resp_header("content-type", "application/activity+json")
+      |> json(ActorView.render("outbox.json", %{actor: actor, page: page}))
+    end
+  end
+
+  def outbox(conn, %{"name" => name}) do
+    with %Actor{} = actor <- Actors.get_local_actor_by_name(name) do
+      conn
+      |> put_resp_header("content-type", "application/activity+json")
+      |> json(ActorView.render("outbox.json", %{actor: actor}))
+    end
+  end
+
+  # TODO: Ensure that this inbox is a recipient of the message
+  def inbox(%{assigns: %{valid_signature: true}} = conn, params) do
+    Logger.debug("Got something with valid signature inside inbox")
+    Federator.enqueue(:incoming_ap_doc, params)
+    json(conn, "ok")
+  end
+
+  # only accept relayed Creates
+  def inbox(conn, %{"type" => "Create"} = params) do
+    Logger.info(
+      "Signature missing or not from author, relayed Create message, fetching object from source"
+    )
+
+    ActivityPub.fetch_object_from_url(params["object"]["id"])
+
+    json(conn, "ok")
+  end
+
+  def inbox(conn, params) do
+    headers = Enum.into(conn.req_headers, %{})
+
+    if String.contains?(headers["signature"], params["actor"]) do
+      Logger.error(
+        "Signature validation error for: #{params["actor"]}, make sure you are forwarding the HTTP Host header!"
+      )
+
+      Logger.debug(inspect(conn.req_headers))
+    end
+
+    json(conn, "error")
+  end
+
+  def relay(conn, _params) do
+    with {status, %Actor{} = actor} when status in [:commit, :ok] <- Cache.get_relay() do
+      conn
+      |> put_resp_header("content-type", "application/activity+json")
+      |> json(ActorView.render("actor.json", %{actor: actor}))
+    end
+  end
+
+  def errors(conn, {:error, :not_found}) do
+    conn
+    |> put_status(404)
+    |> json("Not found")
+  end
+
+  def errors(conn, e) do
+    Logger.debug(inspect(e))
+
+    conn
+    |> put_status(500)
+    |> json("Unknown Error")
+  end
+end

lib/web/controllers/fallback_controller.ex

@@ -0,0 +1,15 @@
+defmodule Mobilizon.Web.FallbackController do
+  @moduledoc """
+  Translates controller action results into valid `Plug.Conn` responses.
+
+  See `Phoenix.Controller.action_fallback/1` for more details.
+  """
+  use Mobilizon.Web, :controller
+
+  def call(conn, {:error, :not_found}) do
+    conn
+    |> put_status(:not_found)
+    |> put_view(Mobilizon.Web.ErrorView)
+    |> render(:"404")
+  end
+end

lib/web/controllers/feed_controller.ex

@@ -0,0 +1,68 @@
+defmodule Mobilizon.Web.FeedController do
+  @moduledoc """
+  Controller to serve RSS, ATOM and iCal Feeds
+  """
+  use Mobilizon.Web, :controller
+  plug(:put_layout, false)
+  action_fallback(Mobilizon.Web.FallbackController)
+
+  def actor(conn, %{"name" => name, "format" => "atom"}) do
+    case Cachex.fetch(:feed, "actor_" <> name) do
+      {status, data} when status in [:commit, :ok] ->
+        conn
+        |> put_resp_content_type("application/atom+xml")
+        |> send_resp(200, data)
+
+      _ ->
+        {:error, :not_found}
+    end
+  end
+
+  def actor(conn, %{"name" => name, "format" => "ics"}) do
+    case Cachex.fetch(:ics, "actor_" <> name) do
+      {status, data} when status in [:commit, :ok] ->
+        conn
+        |> put_resp_content_type("text/calendar")
+        |> send_resp(200, data)
+
+      _ ->
+        {:error, :not_found}
+    end
+  end
+
+  def event(conn, %{"uuid" => uuid, "format" => "ics"}) do
+    case Cachex.fetch(:ics, "event_" <> uuid) do
+      {status, data} when status in [:commit, :ok] ->
+        conn
+        |> put_resp_content_type("text/calendar")
+        |> send_resp(200, data)
+
+      _ ->
+        {:error, :not_found}
+    end
+  end
+
+  def going(conn, %{"token" => token, "format" => "ics"}) do
+    case Cachex.fetch(:ics, "token_" <> token) do
+      {status, data} when status in [:commit, :ok] ->
+        conn
+        |> put_resp_content_type("text/calendar")
+        |> send_resp(200, data)
+
+      _ ->
+        {:error, :not_found}
+    end
+  end
+
+  def going(conn, %{"token" => token, "format" => "atom"}) do
+    case Cachex.fetch(:feed, "token_" <> token) do
+      {status, data} when status in [:commit, :ok] ->
+        conn
+        |> put_resp_content_type("application/atom+xml")
+        |> send_resp(200, data)
+
+      {:ignore, _} ->
+        {:error, :not_found}
+    end
+  end
+end

lib/web/controllers/media_proxy_controller.ex

@@ -0,0 +1,50 @@
+# Portions of this file are derived from Pleroma:
+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+# Upstream: https://git.pleroma.social/pleroma/pleroma/blob/develop/lib/pleroma/web/media_proxy/controller.ex
+
+defmodule Mobilizon.Web.MediaProxyController do
+  use Mobilizon.Web, :controller
+
+  alias Plug.Conn
+
+  alias Mobilizon.Config
+
+  alias Mobilizon.Web.MediaProxy
+  alias Mobilizon.Web.ReverseProxy
+
+  @default_proxy_opts [max_body_length: 25 * 1_048_576, http: [follow_redirect: true]]
+
+  def remote(conn, %{"sig" => sig64, "url" => url64} = params) do
+    with config <- Config.get([:media_proxy], []),
+         true <- Keyword.get(config, :enabled, false),
+         {:ok, url} <- MediaProxy.decode_url(sig64, url64),
+         :ok <- filename_matches(Map.has_key?(params, "filename"), conn.request_path, url) do
+      ReverseProxy.call(conn, url, Keyword.get(config, :proxy_opts, @default_proxy_opts))
+    else
+      false ->
+        send_resp(conn, 404, Conn.Status.reason_phrase(404))
+
+      {:error, :invalid_signature} ->
+        send_resp(conn, 403, Conn.Status.reason_phrase(403))
+
+      {:wrong_filename, filename} ->
+        redirect(conn, external: MediaProxy.build_url(sig64, url64, filename))
+    end
+  end
+
+  def filename_matches(has_filename, path, url) do
+    filename =
+      url
+      |> MediaProxy.filename()
+      |> URI.decode()
+
+    path = URI.decode(path)
+
+    if has_filename && filename && Path.basename(path) != filename do
+      {:wrong_filename, filename}
+    else
+      :ok
+    end
+  end
+end

lib/web/controllers/node_info_controller.ex

@@ -0,0 +1,80 @@
+# Portions of this file are derived from Pleroma:
+# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social>
+# SPDX-License-Identifier: AGPL-3.0-only
+# Upstream: https://git.pleroma.social/pleroma/pleroma/blob/develop/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
+
+defmodule Mobilizon.Web.NodeInfoController do
+  use Mobilizon.Web, :controller
+
+  alias Mobilizon.Config
+  alias Mobilizon.Service.Statistics
+
+  alias Mobilizon.Web.Endpoint
+  alias Mobilizon.Web.Router.Helpers, as: Routes
+
+  @node_info_supported_versions ["2.0", "2.1"]
+  @node_info_schema_uri "http://nodeinfo.diaspora.software/ns/schema/"
+
+  def schemas(conn, _params) do
+    links =
+      @node_info_supported_versions
+      |> Enum.map(fn version ->
+        %{
+          rel: @node_info_schema_uri <> version,
+          href: Routes.node_info_url(Endpoint, :nodeinfo, version)
+        }
+      end)
+
+    json(conn, %{
+      links: links
+    })
+  end
+
+  # Schema definition: https://github.com/jhass/nodeinfo/blob/master/schemas/2.1/schema.json
+  def nodeinfo(conn, %{"version" => version}) when version in @node_info_supported_versions do
+    response = %{
+      version: version,
+      software: %{
+        name: "Mobilizon",
+        version: Config.instance_version()
+      },
+      protocols: ["activitypub"],
+      services: %{
+        inbound: [],
+        outbound: ["atom1.0"]
+      },
+      openRegistrations: Config.instance_registrations_open?(),
+      usage: %{
+        users: %{
+          total: Statistics.get_cached_value(:local_users)
+        },
+        localPosts: Statistics.get_cached_value(:local_events),
+        localComments: Statistics.get_cached_value(:local_comments)
+      },
+      metadata: %{
+        nodeName: Config.instance_name(),
+        nodeDescription: Config.instance_description()
+      }
+    }
+
+    response =
+      if version == "2.1" do
+        put_in(response, [:software, :repository], Config.instance_repository())
+      else
+        response
+      end
+
+    conn
+    |> put_resp_header(
+      "content-type",
+      "application/json; profile=http://nodeinfo.diaspora.software/ns/schema/2.1#; charset=utf-8"
+    )
+    |> json(response)
+  end
+
+  def nodeinfo(conn, _) do
+    conn
+    |> put_status(404)
+    |> json(%{error: "Nodeinfo schema version not handled"})
+  end
+end

lib/web/controllers/page_controller.ex

@@ -0,0 +1,52 @@
+defmodule Mobilizon.Web.PageController do
+  @moduledoc """
+  Controller to load our webapp
+  """
+  use Mobilizon.Web, :controller
+
+  alias Mobilizon.Web.Cache
+
+  plug(:put_layout, false)
+  action_fallback(Mobilizon.Web.FallbackController)
+
+  def index(conn, _params), do: render(conn, :index)
+
+  def actor(conn, %{"name" => name}) do
+    {status, actor} = Cache.get_local_actor_by_name(name)
+    render_or_error(conn, &ok_status?/2, status, :actor, actor)
+  end
+
+  def event(conn, %{"uuid" => uuid}) do
+    {status, event} = Cache.get_public_event_by_uuid_with_preload(uuid)
+    render_or_error(conn, &ok_status_and_is_visible?/2, status, :event, event)
+  end
+
+  def comment(conn, %{"uuid" => uuid}) do
+    {status, comment} = Cache.get_comment_by_uuid_with_preload(uuid)
+    render_or_error(conn, &ok_status_and_is_visible?/2, status, :comment, comment)
+  end
+
+  defp render_or_error(conn, check_fn, status, object_type, object) do
+    if check_fn.(status, object) do
+      case object do
+        %Mobilizon.Tombstone{} ->
+          conn
+          |> put_status(:gone)
+          |> render(object_type, object: object)
+
+        _ ->
+          render(conn, object_type, object: object)
+      end
+    else
+      {:error, :not_found}
+    end
+  end
+
+  defp is_visible?(%{visibility: v}), do: v in [:public, :unlisted]
+  defp is_visible?(%Mobilizon.Tombstone{}), do: true
+
+  defp ok_status?(status), do: status in [:ok, :commit]
+  defp ok_status?(status, _), do: ok_status?(status)
+
+  defp ok_status_and_is_visible?(status, o), do: ok_status?(status) and is_visible?(o)
+end

lib/web/controllers/web_finger_controller.ex

@@ -0,0 +1,39 @@
+# Portions of this file are derived from Pleroma:
+# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social>
+# SPDX-License-Identifier: AGPL-3.0-only
+# Upstream: https://git.pleroma.social/pleroma/pleroma/blob/develop/lib/pleroma/web/web_finger/web_finger_controller.ex
+
+defmodule Mobilizon.Web.WebFingerController do
+  @moduledoc """
+  Handles Webfinger requests
+  """
+
+  use Mobilizon.Web, :controller
+
+  alias Mobilizon.Federation.WebFinger
+
+  plug(Mobilizon.Web.Plugs.Federating)
+
+  @doc """
+  Provides /.well-known/host-meta
+  """
+  def host_meta(conn, _params) do
+    xml = WebFinger.host_meta()
+
+    conn
+    |> put_resp_content_type("application/xrd+xml")
+    |> send_resp(200, xml)
+  end
+
+  @doc """
+  Provides /.well-known/webfinger
+  """
+  def webfinger(conn, %{"resource" => resource}) do
+    case WebFinger.webfinger(resource, "JSON") do
+      {:ok, response} -> json(conn, response)
+      _e -> send_resp(conn, 404, "Couldn't find user")
+    end
+  end
+
+  def webfinger(conn, _), do: send_resp(conn, 400, "No query provided")
+end