docs/docs/development/API/admin_api.md

@@ -1636,3 +1636,117 @@ Returns the content of the document
   "error": "Could not install frontend"
 }
 ```
+
+## `GET /api/v1/pleroma/admin/announcements`
+
+### List announcements
+
+- Params: `offset`, `limit`
+
+- Response: JSON, list of announcements
+
+```json
+[
+  {
+    "id": "AHDp0GBdRn1EPN5HN2",
+    "content": "some content",
+    "starts_at": null,
+    "ends_at": null,
+    "all_day": false,
+    "published_at": "2022-03-09T02:13:05",
+    "reactions": [],
+    "statuses": [],
+    "tags": [],
+    "emojis": [],
+    "updated_at": "2022-03-09T02:13:05"
+  }
+]
+```
+
+Note that this differs from the Mastodon API variant: Mastodon API only returns *active* announcements, while this returns all.
+
+## `GET /api/v1/pleroma/admin/announcements/:id`
+
+### Display one announcement
+
+- Response: JSON, one announcement
+
+```json
+{
+  "id": "AHDp0GBdRn1EPN5HN2",
+  "content": "some content",
+  "starts_at": null,
+  "ends_at": null,
+  "all_day": false,
+  "published_at": "2022-03-09T02:13:05",
+  "reactions": [],
+  "statuses": [],
+  "tags": [],
+  "emojis": [],
+  "updated_at": "2022-03-09T02:13:05"
+}
+```
+
+## `POST /api/v1/pleroma/admin/announcements`
+
+### Create an announcement
+
+- Params:
+  - `content`: string, required, announcement content
+  - `starts_at`: datetime, optional, default to null, the time when the announcement will become active (displayed to users); if it is null, the announcement will be active immediately
+  - `ends_at`: datetime, optional, default to null, the time when the announcement will become inactive (no longer displayed to users); if it is null, the announcement will be active until an admin deletes it
+  - `all_day`: boolean, optional, default to false, tells the client whether to only display dates for `starts_at` and `ends_at`
+
+- Response: JSON, created announcement
+
+```json
+{
+  "id": "AHDp0GBdRn1EPN5HN2",
+  "content": "some content",
+  "starts_at": null,
+  "ends_at": null,
+  "all_day": false,
+  "published_at": "2022-03-09T02:13:05",
+  "reactions": [],
+  "statuses": [],
+  "tags": [],
+  "emojis": [],
+  "updated_at": "2022-03-09T02:13:05"
+}
+```
+
+## `PATCH /api/v1/pleroma/admin/announcements/:id`
+
+### Change an announcement
+
+- Params: same as `POST /api/v1/pleroma/admin/announcements`, except no param is required.
+
+- Updates the announcement according to params. Missing params are kept as-is.
+
+- Response: JSON, updated announcement
+
+```json
+{
+  "id": "AHDp0GBdRn1EPN5HN2",
+  "content": "some content",
+  "starts_at": null,
+  "ends_at": null,
+  "all_day": false,
+  "published_at": "2022-03-09T02:13:05",
+  "reactions": [],
+  "statuses": [],
+  "tags": [],
+  "emojis": [],
+  "updated_at": "2022-03-09T02:13:05"
+}
+```
+
+## `DELETE /api/v1/pleroma/admin/announcements/:id`
+
+### Delete an announcement
+
+- Response: JSON, empty object
+
+```json
+{}
+```

lib/pleroma/announcement.ex

@@ -0,0 +1,160 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Announcement do
+  use Ecto.Schema
+
+  import Ecto.Changeset, only: [cast: 3, validate_required: 2]
+  import Ecto.Query
+
+  alias Pleroma.AnnouncementReadRelationship
+  alias Pleroma.Repo
+
+  @type t :: %__MODULE__{}
+  @primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}
+
+  schema "announcements" do
+    field(:data, :map)
+    field(:starts_at, :utc_datetime)
+    field(:ends_at, :utc_datetime)
+    field(:rendered, :map)
+
+    timestamps(type: :utc_datetime)
+  end
+
+  def change(struct, params \\ %{}) do
+    struct
+    |> cast(validate_params(struct, params), [:data, :starts_at, :ends_at, :rendered])
+    |> validate_required([:data])
+  end
+
+  defp validate_params(struct, params) do
+    base_data =
+      %{
+        "content" => "",
+        "all_day" => false
+      }
+      |> Map.merge((struct && struct.data) || %{})
+
+    merged_data =
+      Map.merge(base_data, params.data)
+      |> Map.take(["content", "all_day"])
+
+    params
+    |> Map.merge(%{data: merged_data})
+    |> add_rendered_properties()
+  end
+
+  def add_rendered_properties(params) do
+    {content_html, _, _} =
+      Pleroma.Web.CommonAPI.Utils.format_input(params.data["content"], "text/plain",
+        mentions_format: :full
+      )
+
+    rendered = %{
+      "content" => content_html
+    }
+
+    params
+    |> Map.put(:rendered, rendered)
+  end
+
+  def add(params) do
+    changeset = change(%__MODULE__{}, params)
+
+    Repo.insert(changeset)
+  end
+
+  def update(announcement, params) do
+    changeset = change(announcement, params)
+
+    Repo.update(changeset)
+  end
+
+  def list_all do
+    __MODULE__
+    |> Repo.all()
+  end
+
+  def list_paginated(%{limit: limited_number, offset: offset_number}) do
+    __MODULE__
+    |> limit(^limited_number)
+    |> offset(^offset_number)
+    |> Repo.all()
+  end
+
+  def get_by_id(id) do
+    Repo.get_by(__MODULE__, id: id)
+  end
+
+  def delete_by_id(id) do
+    with announcement when not is_nil(announcement) <- get_by_id(id),
+         {:ok, _} <- Repo.delete(announcement) do
+      :ok
+    else
+      _ ->
+        :error
+    end
+  end
+
+  def read_by?(announcement, user) do
+    AnnouncementReadRelationship.exists?(user, announcement)
+  end
+
+  def mark_read_by(announcement, user) do
+    AnnouncementReadRelationship.mark_read(user, announcement)
+  end
+
+  def render_json(announcement, opts \\ []) do
+    extra_params =
+      case Keyword.fetch(opts, :for) do
+        {:ok, user} when not is_nil(user) ->
+          %{read: read_by?(announcement, user)}
+
+        _ ->
+          %{}
+      end
+
+    admin_extra_params =
+      case Keyword.fetch(opts, :admin) do
+        {:ok, true} ->
+          %{pleroma: %{raw_content: announcement.data["content"]}}
+
+        _ ->
+          %{}
+      end
+
+    base = %{
+      id: announcement.id,
+      content: announcement.rendered["content"],
+      starts_at: announcement.starts_at,
+      ends_at: announcement.ends_at,
+      all_day: announcement.data["all_day"],
+      published_at: announcement.inserted_at,
+      updated_at: announcement.updated_at,
+      mentions: [],
+      statuses: [],
+      tags: [],
+      emojis: [],
+      reactions: []
+    }
+
+    base
+    |> Map.merge(extra_params)
+    |> Map.merge(admin_extra_params)
+  end
+
+  # "visible" means:
+  # starts_at < time < ends_at
+  def list_all_visible_when(time) do
+    __MODULE__
+    |> where([a], is_nil(a.starts_at) or a.starts_at < ^time)
+    |> where([a], is_nil(a.ends_at) or a.ends_at > ^time)
+    |> Repo.all()
+  end
+
+  def list_all_visible do
+    list_all_visible_when(DateTime.now("Etc/UTC") |> elem(1))
+  end
+end

lib/pleroma/announcement_read_relationship.ex

@@ -0,0 +1,55 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.AnnouncementReadRelationship do
+  use Ecto.Schema
+
+  import Ecto.Changeset
+
+  alias FlakeId.Ecto.CompatType
+  alias Pleroma.Announcement
+  alias Pleroma.Repo
+  alias Pleroma.User
+
+  @type t :: %__MODULE__{}
+
+  schema "announcement_read_relationships" do
+    belongs_to(:user, User, type: CompatType)
+    belongs_to(:announcement, Announcement, type: CompatType)
+
+    timestamps(updated_at: false)
+  end
+
+  def mark_read(user, announcement) do
+    %__MODULE__{}
+    |> cast(%{user_id: user.id, announcement_id: announcement.id}, [:user_id, :announcement_id])
+    |> validate_required([:user_id, :announcement_id])
+    |> foreign_key_constraint(:user_id)
+    |> foreign_key_constraint(:announcement_id)
+    |> unique_constraint([:user_id, :announcement_id])
+    |> Repo.insert()
+  end
+
+  def mark_unread(user, announcement) do
+    with relationship <- get(user, announcement),
+         {:exists, true} <- {:exists, not is_nil(relationship)},
+         {:ok, _} <- Repo.delete(relationship) do
+      :ok
+    else
+      {:exists, false} ->
+        :ok
+
+      _ ->
+        :error
+    end
+  end
+
+  def get(user, announcement) do
+    Repo.get_by(__MODULE__, user_id: user.id, announcement_id: announcement.id)
+  end
+
+  def exists?(user, announcement) do
+    not is_nil(get(user, announcement))
+  end
+end

lib/pleroma/web/admin_api/controllers/announcement_controller.ex

@@ -0,0 +1,83 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.AdminAPI.AnnouncementController do
+  use Pleroma.Web, :controller
+
+  alias Pleroma.Announcement
+  alias Pleroma.Web.ControllerHelper
+  alias Pleroma.Web.Plugs.OAuthScopesPlug
+
+  plug(Pleroma.Web.ApiSpec.CastAndValidate)
+  plug(OAuthScopesPlug, %{scopes: ["admin:write"]} when action in [:create, :delete, :change])
+  plug(OAuthScopesPlug, %{scopes: ["admin:read"]} when action in [:index, :show])
+  action_fallback(Pleroma.Web.AdminAPI.FallbackController)
+
+  defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.Admin.AnnouncementOperation
+
+  defp default_limit, do: 20
+
+  def index(conn, params) do
+    limit = Map.get(params, :limit, default_limit())
+    offset = Map.get(params, :offset, 0)
+
+    announcements = Announcement.list_paginated(%{limit: limit, offset: offset})
+
+    render(conn, "index.json", announcements: announcements)
+  end
+
+  def show(conn, %{id: id} = _params) do
+    announcement = Announcement.get_by_id(id)
+
+    if is_nil(announcement) do
+      {:error, :not_found}
+    else
+      render(conn, "show.json", announcement: announcement)
+    end
+  end
+
+  def create(%{body_params: params} = conn, _params) do
+    with {:ok, announcement} <- Announcement.add(change_params(params)) do
+      render(conn, "show.json", announcement: announcement)
+    else
+      _ ->
+        {:error, 400}
+    end
+  end
+
+  def change_params(orig_params) do
+    data =
+      %{}
+      |> Pleroma.Maps.put_if_present("content", orig_params, &Map.fetch(&1, :content))
+      |> Pleroma.Maps.put_if_present("all_day", orig_params, &Map.fetch(&1, :all_day))
+
+    orig_params
+    |> Map.merge(%{data: data})
+  end
+
+  def change(%{body_params: params} = conn, %{id: id} = _params) do
+    with announcement <- Announcement.get_by_id(id),
+         {:exists, true} <- {:exists, not is_nil(announcement)},
+         {:ok, announcement} <- Announcement.update(announcement, change_params(params)) do
+      render(conn, "show.json", announcement: announcement)
+    else
+      {:exists, false} ->
+        {:error, :not_found}
+
+      _ ->
+        {:error, 400}
+    end
+  end
+
+  def delete(conn, %{id: id} = _params) do
+    case Announcement.delete_by_id(id) do
+      :ok ->
+        conn
+        |> ControllerHelper.json_response(:ok, %{})
+
+      _ ->
+        {:error, :not_found}
+    end
+  end
+end

lib/pleroma/web/admin_api/views/announcement_view.ex

@@ -0,0 +1,15 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.AdminAPI.AnnouncementView do
+  use Pleroma.Web, :view
+
+  def render("index.json", %{announcements: announcements}) do
+    render_many(announcements, __MODULE__, "show.json")
+  end
+
+  def render("show.json", %{announcement: announcement}) do
+    Pleroma.Announcement.render_json(announcement, admin: true)
+  end
+end

lib/pleroma/web/api_spec/operations/admin/announcement_operation.ex

@@ -0,0 +1,165 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.ApiSpec.Admin.AnnouncementOperation do
+  alias OpenApiSpex.Operation
+  alias OpenApiSpex.Schema
+  alias Pleroma.Web.ApiSpec.Schemas.Announcement
+  alias Pleroma.Web.ApiSpec.Schemas.ApiError
+
+  import Pleroma.Web.ApiSpec.Helpers
+
+  def open_api_operation(action) do
+    operation = String.to_existing_atom("#{action}_operation")
+    apply(__MODULE__, operation, [])
+  end
+
+  def index_operation do
+    %Operation{
+      tags: ["Announcement managment"],
+      summary: "Retrieve a list of announcements",
+      operationId: "AdminAPI.AnnouncementController.index",
+      security: [%{"oAuth" => ["admin:read"]}],
+      parameters: [
+        Operation.parameter(
+          :limit,
+          :query,
+          %Schema{type: :integer, minimum: 1},
+          "the maximum number of announcements to return"
+        ),
+        Operation.parameter(
+          :offset,
+          :query,
+          %Schema{type: :integer, minimum: 0},
+          "the offset of the first announcement to return"
+        )
+        | admin_api_params()
+      ],
+      responses: %{
+        200 => Operation.response("Response", "application/json", list_of_announcements()),
+        400 => Operation.response("Forbidden", "application/json", ApiError),
+        403 => Operation.response("Forbidden", "application/json", ApiError)
+      }
+    }
+  end
+
+  def show_operation do
+    %Operation{
+      tags: ["Announcement managment"],
+      summary: "Display one announcement",
+      operationId: "AdminAPI.AnnouncementController.show",
+      security: [%{"oAuth" => ["admin:read"]}],
+      parameters: [
+        Operation.parameter(
+          :id,
+          :path,
+          :string,
+          "announcement id"
+        )
+        | admin_api_params()
+      ],
+      responses: %{
+        200 => Operation.response("Response", "application/json", Announcement),
+        403 => Operation.response("Forbidden", "application/json", ApiError),
+        404 => Operation.response("Not Found", "application/json", ApiError)
+      }
+    }
+  end
+
+  def delete_operation do
+    %Operation{
+      tags: ["Announcement managment"],
+      summary: "Delete one announcement",
+      operationId: "AdminAPI.AnnouncementController.delete",
+      security: [%{"oAuth" => ["admin:write"]}],
+      parameters: [
+        Operation.parameter(
+          :id,
+          :path,
+          :string,
+          "announcement id"
+        )
+        | admin_api_params()
+      ],
+      responses: %{
+        200 => Operation.response("Response", "application/json", %Schema{type: :object}),
+        403 => Operation.response("Forbidden", "application/json", ApiError),
+        404 => Operation.response("Not Found", "application/json", ApiError)
+      }
+    }
+  end
+
+  def create_operation do
+    %Operation{
+      tags: ["Announcement managment"],
+      summary: "Create one announcement",
+      operationId: "AdminAPI.AnnouncementController.create",
+      security: [%{"oAuth" => ["admin:write"]}],
+      requestBody: request_body("Parameters", create_request(), required: true),
+      responses: %{
+        200 => Operation.response("Response", "application/json", Announcement),
+        400 => Operation.response("Bad Request", "application/json", ApiError),
+        403 => Operation.response("Forbidden", "application/json", ApiError)
+      }
+    }
+  end
+
+  def change_operation do
+    %Operation{
+      tags: ["Announcement managment"],
+      summary: "Change one announcement",
+      operationId: "AdminAPI.AnnouncementController.change",
+      security: [%{"oAuth" => ["admin:write"]}],
+      parameters: [
+        Operation.parameter(
+          :id,
+          :path,
+          :string,
+          "announcement id"
+        )
+        | admin_api_params()
+      ],
+      requestBody: request_body("Parameters", change_request(), required: true),
+      responses: %{
+        200 => Operation.response("Response", "application/json", Announcement),
+        400 => Operation.response("Bad Request", "application/json", ApiError),
+        403 => Operation.response("Forbidden", "application/json", ApiError),
+        404 => Operation.response("Not Found", "application/json", ApiError)
+      }
+    }
+  end
+
+  defp create_or_change_props do
+    %{
+      content: %Schema{type: :string},
+      starts_at: %Schema{type: :string, format: "date-time", nullable: true},
+      ends_at: %Schema{type: :string, format: "date-time", nullable: true},
+      all_day: %Schema{type: :boolean}
+    }
+  end
+
+  def create_request do
+    %Schema{
+      title: "AnnouncementCreateRequest",
+      type: :object,
+      required: [:content],
+      properties: create_or_change_props()
+    }
+  end
+
+  def change_request do
+    %Schema{
+      title: "AnnouncementChangeRequest",
+      type: :object,
+      properties: create_or_change_props()
+    }
+  end
+
+  def list_of_announcements do
+    %Schema{
+      type: :array,
+      items: Announcement
+    }
+  end
+end

lib/pleroma/web/api_spec/operations/announcement_operation.ex

@@ -0,0 +1,57 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.ApiSpec.AnnouncementOperation do
+  alias OpenApiSpex.Operation
+  alias OpenApiSpex.Schema
+  alias Pleroma.Web.ApiSpec.Schemas.Announcement
+  alias Pleroma.Web.ApiSpec.Schemas.ApiError
+
+  def open_api_operation(action) do
+    operation = String.to_existing_atom("#{action}_operation")
+    apply(__MODULE__, operation, [])
+  end
+
+  def index_operation do
+    %Operation{
+      tags: ["Announcement"],
+      summary: "Retrieve a list of announcements",
+      operationId: "MastodonAPI.AnnouncementController.index",
+      security: [%{"oAuth" => []}],
+      responses: %{
+        200 => Operation.response("Response", "application/json", list_of_announcements()),
+        403 => Operation.response("Forbidden", "application/json", ApiError)
+      }
+    }
+  end
+
+  def mark_read_operation do
+    %Operation{
+      tags: ["Announcement"],
+      summary: "Mark one announcement as read",
+      operationId: "MastodonAPI.AnnouncementController.mark_read",
+      security: [%{"oAuth" => ["write:accounts"]}],
+      parameters: [
+        Operation.parameter(
+          :id,
+          :path,
+          :string,
+          "announcement id"
+        )
+      ],
+      responses: %{
+        200 => Operation.response("Response", "application/json", %Schema{type: :object}),
+        403 => Operation.response("Forbidden", "application/json", ApiError),
+        404 => Operation.response("Not Found", "application/json", ApiError)
+      }
+    }
+  end
+
+  def list_of_announcements do
+    %Schema{
+      type: :array,
+      items: Announcement
+    }
+  end
+end

lib/pleroma/web/api_spec/schemas/announcement.ex

@@ -0,0 +1,45 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.ApiSpec.Schemas.Announcement do
+  alias OpenApiSpex.Schema
+  alias Pleroma.Web.ApiSpec.Schemas.FlakeID
+
+  require OpenApiSpex
+
+  OpenApiSpex.schema(%{
+    title: "Announcement",
+    description: "Response schema for an announcement",
+    type: :object,
+    properties: %{
+      id: FlakeID,
+      content: %Schema{type: :string},
+      starts_at: %Schema{
+        type: :string,
+        format: "date-time",
+        nullable: true
+      },
+      ends_at: %Schema{
+        type: :string,
+        format: "date-time",
+        nullable: true
+      },
+      all_day: %Schema{type: :boolean},
+      published_at: %Schema{type: :string, format: "date-time"},
+      updated_at: %Schema{type: :string, format: "date-time"},
+      read: %Schema{type: :boolean},
+      mentions: %Schema{type: :array},
+      statuses: %Schema{type: :array},
+      tags: %Schema{type: :array},
+      emojis: %Schema{type: :array},
+      reactions: %Schema{type: :array},
+      pleroma: %Schema{
+        type: :object,
+        properties: %{
+          raw_content: %Schema{type: :string}
+        }
+      }
+    }
+  })
+end

lib/pleroma/web/mastodon_api/controllers/announcement_controller.ex

@@ -0,0 +1,60 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.MastodonAPI.AnnouncementController do
+  use Pleroma.Web, :controller
+
+  import Pleroma.Web.ControllerHelper,
+    only: [
+      json_response: 3
+    ]
+
+  alias Pleroma.Announcement
+  alias Pleroma.Web.Plugs.OAuthScopesPlug
+
+  plug(Pleroma.Web.ApiSpec.CastAndValidate)
+
+  # Mastodon docs say this only requires a user token, no scopes needed
+  # As the op `|` requires at least one scope to be present, we use `&` here.
+  plug(
+    OAuthScopesPlug,
+    %{scopes: [], op: :&}
+    when action in [:index]
+  )
+
+  # Same as in MastodonAPI specs
+  plug(
+    OAuthScopesPlug,
+    %{scopes: ["write:accounts"]}
+    when action in [:mark_read]
+  )
+
+  action_fallback(Pleroma.Web.MastodonAPI.FallbackController)
+
+  defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.AnnouncementOperation
+
+  @doc "GET /api/v1/announcements"
+  def index(%{assigns: %{user: user}} = conn, _params) do
+    render(conn, "index.json", announcements: all_visible(), user: user)
+  end
+
+  def index(conn, _params) do
+    render(conn, "index.json", announcements: all_visible(), user: nil)
+  end
+
+  defp all_visible do
+    Announcement.list_all_visible()
+  end
+
+  @doc "POST /api/v1/announcements/:id/dismiss"
+  def mark_read(%{assigns: %{user: user}} = conn, %{id: id} = _params) do
+    with announcement when not is_nil(announcement) <- Announcement.get_by_id(id),
+         {:ok, _} <- Announcement.mark_read_by(announcement, user) do
+      json_response(conn, :ok, %{})
+    else
+      _ ->
+        {:error, :not_found}
+    end
+  end
+end

lib/pleroma/web/mastodon_api/views/announcement_view.ex

@@ -0,0 +1,15 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.MastodonAPI.AnnouncementView do
+  use Pleroma.Web, :view
+
+  def render("index.json", %{announcements: announcements, user: user}) do
+    render_many(announcements, __MODULE__, "show.json", user: user)
+  end
+
+  def render("show.json", %{announcement: announcement, user: user}) do
+    Pleroma.Announcement.render_json(announcement, for: user)
+  end
+end

lib/pleroma/web/router.ex

@@ -235,6 +235,12 @@ defmodule Pleroma.Web.Router do
     post("/frontends/install", FrontendController, :install)
 
     post("/backups", AdminAPIController, :create_backup)
+
+    get("/announcements", AnnouncementController, :index)
+    post("/announcements", AnnouncementController, :create)
+    get("/announcements/:id", AnnouncementController, :show)
+    patch("/announcements/:id", AnnouncementController, :change)
+    delete("/announcements/:id", AnnouncementController, :delete)
   end
 
   # AdminAPI: admins and mods (staff) can perform these actions (if enabled by config)
@@ -581,6 +587,9 @@ defmodule Pleroma.Web.Router do
     get("/timelines/home", TimelineController, :home)
     get("/timelines/direct", TimelineController, :direct)
     get("/timelines/list/:list_id", TimelineController, :list)
+
+    get("/announcements", AnnouncementController, :index)
+    post("/announcements/:id/dismiss", AnnouncementController, :mark_read)
   end
 
   scope "/api/web", Pleroma.Web do

priv/repo/migrations/20220308012601_create_announcements.exs

@@ -0,0 +1,26 @@
+defmodule Pleroma.Repo.Migrations.CreateAnnouncements do
+  use Ecto.Migration
+
+  def change do
+    create_if_not_exists table(:announcements, primary_key: false) do
+      add(:id, :uuid, primary_key: true)
+      add(:data, :map)
+      add(:starts_at, :naive_datetime)
+      add(:ends_at, :naive_datetime)
+      add(:rendered, :map)
+
+      timestamps()
+    end
+
+    create_if_not_exists table(:announcement_read_relationships) do
+      add(:user_id, references(:users, type: :uuid, on_delete: :delete_all))
+      add(:announcement_id, references(:announcements, type: :uuid, on_delete: :delete_all))
+
+      timestamps(updated_at: false)
+    end
+
+    create_if_not_exists(
+      unique_index(:announcement_read_relationships, [:user_id, :announcement_id])
+    )
+  end
+end

test/pleroma/announcement_read_relationship_test.exs

@@ -0,0 +1,40 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.AnnouncementReadRelationshipTest do
+  alias Pleroma.AnnouncementReadRelationship
+
+  use Pleroma.DataCase, async: true
+
+  import Pleroma.Factory
+
+  setup do
+    {:ok, user: insert(:user), announcement: insert(:announcement)}
+  end
+
+  describe "mark_read/2" do
+    test "should insert relationship", %{user: user, announcement: announcement} do
+      {:ok, _} = AnnouncementReadRelationship.mark_read(user, announcement)
+
+      assert AnnouncementReadRelationship.exists?(user, announcement)
+    end
+  end
+
+  describe "mark_unread/2" do
+    test "should delete relationship", %{user: user, announcement: announcement} do
+      {:ok, _} = AnnouncementReadRelationship.mark_read(user, announcement)
+
+      assert :ok = AnnouncementReadRelationship.mark_unread(user, announcement)
+      refute AnnouncementReadRelationship.exists?(user, announcement)
+    end
+
+    test "should not fail if relationship does not exist", %{
+      user: user,
+      announcement: announcement
+    } do
+      assert :ok = AnnouncementReadRelationship.mark_unread(user, announcement)
+      refute AnnouncementReadRelationship.exists?(user, announcement)
+    end
+  end
+end

test/pleroma/announcement_test.exs

@@ -0,0 +1,98 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.AnnouncementTest do
+  alias Pleroma.Announcement
+
+  use Pleroma.DataCase, async: true
+
+  import Pleroma.Factory
+
+  describe "list_all_visible_when/1" do
+    setup do: {:ok, time: NaiveDateTime.utc_now()}
+
+    test "with no start or end time", %{time: time} do
+      _announcement = insert(:announcement)
+
+      assert [_] = Announcement.list_all_visible_when(time)
+    end
+
+    test "with start time before current", %{time: time} do
+      before_now = NaiveDateTime.add(time, -10, :second)
+
+      _announcement = insert(:announcement, %{starts_at: before_now})
+
+      assert [_] = Announcement.list_all_visible_when(time)
+    end
+
+    test "with start time after current", %{time: time} do
+      after_now = NaiveDateTime.add(time, 10, :second)
+
+      _announcement = insert(:announcement, %{starts_at: after_now})
+
+      assert [] = Announcement.list_all_visible_when(time)
+    end
+
+    test "with end time after current", %{time: time} do
+      after_now = NaiveDateTime.add(time, 10, :second)
+
+      _announcement = insert(:announcement, %{ends_at: after_now})
+
+      assert [_] = Announcement.list_all_visible_when(time)
+    end
+
+    test "with end time before current", %{time: time} do
+      before_now = NaiveDateTime.add(time, -10, :second)
+
+      _announcement = insert(:announcement, %{ends_at: before_now})
+
+      assert [] = Announcement.list_all_visible_when(time)
+    end
+
+    test "with both start and end time", %{time: time} do
+      before_now = NaiveDateTime.add(time, -10, :second)
+      after_now = NaiveDateTime.add(time, 10, :second)
+
+      _announcement = insert(:announcement, %{starts_at: before_now, ends_at: after_now})
+
+      assert [_] = Announcement.list_all_visible_when(time)
+    end
+
+    test "with both start and end time, current not in the range", %{time: time} do
+      before_now = NaiveDateTime.add(time, -10, :second)
+      after_now = NaiveDateTime.add(time, 10, :second)
+
+      _announcement = insert(:announcement, %{starts_at: after_now, ends_at: before_now})
+
+      assert [] = Announcement.list_all_visible_when(time)
+    end
+  end
+
+  describe "announcements formatting" do
+    test "it formats links" do
+      raw = "something on https://pleroma.social ."
+      announcement = insert(:announcement, %{data: %{"content" => raw}})
+
+      assert announcement.rendered["content"] =~ ~r(<a.+?https://pleroma.social)
+      assert announcement.data["content"] == raw
+    end
+
+    test "it formats mentions" do
+      user = insert(:user)
+      raw = "something on @#{user.nickname} ."
+      announcement = insert(:announcement, %{data: %{"content" => raw}})
+
+      assert announcement.rendered["content"] =~ ~r(<a.+?#{user.nickname})
+      assert announcement.data["content"] == raw
+    end
+
+    test "it formats tags" do
+      raw = "something on #mew ."
+      announcement = insert(:announcement, %{data: %{"content" => raw}})
+
+      assert announcement.rendered["content"] =~ ~r(<a.+?#mew)
+      assert announcement.data["content"] == raw
+    end
+  end
+end

test/pleroma/web/admin_api/controllers/announcement_controller_test.exs

@@ -0,0 +1,281 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.AdminAPI.AnnouncementControllerTest do
+  use Pleroma.Web.ConnCase
+
+  import Pleroma.Factory
+
+  setup do
+    admin = insert(:user, is_admin: true)
+    token = insert(:oauth_admin_token, user: admin)
+
+    conn =
+      build_conn()
+      |> assign(:user, admin)
+      |> assign(:token, token)
+
+    {:ok, %{admin: admin, token: token, conn: conn}}
+  end
+
+  describe "GET /api/v1/pleroma/admin/announcements" do
+    test "it lists all announcements", %{conn: conn} do
+      %{id: id} = insert(:announcement)
+
+      response =
+        conn
+        |> get("/api/v1/pleroma/admin/announcements")
+        |> json_response_and_validate_schema(:ok)
+
+      assert [%{"id" => ^id}] = response
+    end
+
+    test "it paginates announcements", %{conn: conn} do
+      _announcements = Enum.map(0..20, fn _ -> insert(:announcement) end)
+
+      response =
+        conn
+        |> get("/api/v1/pleroma/admin/announcements")
+        |> json_response_and_validate_schema(:ok)
+
+      assert length(response) == 20
+    end
+
+    test "it paginates announcements with custom params", %{conn: conn} do
+      announcements = Enum.map(0..20, fn _ -> insert(:announcement) end)
+
+      response =
+        conn
+        |> get("/api/v1/pleroma/admin/announcements", limit: 5, offset: 7)
+        |> json_response_and_validate_schema(:ok)
+
+      assert length(response) == 5
+      assert Enum.at(response, 0)["id"] == Enum.at(announcements, 7).id
+    end
+
+    test "it returns empty list with out-of-bounds offset", %{conn: conn} do
+      _announcements = Enum.map(0..20, fn _ -> insert(:announcement) end)
+
+      response =
+        conn
+        |> get("/api/v1/pleroma/admin/announcements", offset: 21)
+        |> json_response_and_validate_schema(:ok)
+
+      assert [] = response
+    end
+
+    test "it rejects invalid pagination params", %{conn: conn} do
+      conn
+      |> get("/api/v1/pleroma/admin/announcements", limit: 0)
+      |> json_response_and_validate_schema(400)
+
+      conn
+      |> get("/api/v1/pleroma/admin/announcements", limit: -1)
+      |> json_response_and_validate_schema(400)
+
+      conn
+      |> get("/api/v1/pleroma/admin/announcements", offset: -1)
+      |> json_response_and_validate_schema(400)
+    end
+  end
+
+  describe "GET /api/v1/pleroma/admin/announcements/:id" do
+    test "it displays one announcement", %{conn: conn} do
+      %{id: id} = insert(:announcement)
+
+      response =
+        conn
+        |> get("/api/v1/pleroma/admin/announcements/#{id}")
+        |> json_response_and_validate_schema(:ok)
+
+      assert %{"id" => ^id} = response
+    end
+
+    test "it returns not found for non-existent id", %{conn: conn} do
+      %{id: id} = insert(:announcement)
+
+      _response =
+        conn
+        |> get("/api/v1/pleroma/admin/announcements/#{id}xxx")
+        |> json_response_and_validate_schema(:not_found)
+    end
+  end
+
+  describe "DELETE /api/v1/pleroma/admin/announcements/:id" do
+    test "it deletes specified announcement", %{conn: conn} do
+      %{id: id} = insert(:announcement)
+
+      _response =
+        conn
+        |> delete("/api/v1/pleroma/admin/announcements/#{id}")
+        |> json_response_and_validate_schema(:ok)
+    end
+
+    test "it returns not found for non-existent id", %{conn: conn} do
+      %{id: id} = insert(:announcement)
+
+      _response =
+        conn
+        |> delete("/api/v1/pleroma/admin/announcements/#{id}xxx")
+        |> json_response_and_validate_schema(:not_found)
+
+      assert %{id: ^id} = Pleroma.Announcement.get_by_id(id)
+    end
+  end
+
+  describe "PATCH /api/v1/pleroma/admin/announcements/:id" do
+    test "it returns not found for non-existent id", %{conn: conn} do
+      %{id: id} = insert(:announcement)
+
+      _response =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> patch("/api/v1/pleroma/admin/announcements/#{id}xxx", %{})
+        |> json_response_and_validate_schema(:not_found)
+
+      assert %{id: ^id} = Pleroma.Announcement.get_by_id(id)
+    end
+
+    test "it updates a field", %{conn: conn} do
+      %{id: id} = insert(:announcement)
+
+      now = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)
+      starts_at = NaiveDateTime.add(now, -10, :second)
+
+      _response =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> patch("/api/v1/pleroma/admin/announcements/#{id}", %{
+          starts_at: NaiveDateTime.to_iso8601(starts_at)
+        })
+        |> json_response_and_validate_schema(:ok)
+
+      new = Pleroma.Announcement.get_by_id(id)
+
+      assert NaiveDateTime.compare(new.starts_at, starts_at) == :eq
+    end
+
+    test "it updates with time with utc timezone", %{conn: conn} do
+      %{id: id} = insert(:announcement)
+
+      now = DateTime.now("Etc/UTC") |> elem(1) |> DateTime.truncate(:second)
+      starts_at = DateTime.add(now, -10, :second)
+
+      _response =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> patch("/api/v1/pleroma/admin/announcements/#{id}", %{
+          starts_at: DateTime.to_iso8601(starts_at)
+        })
+        |> json_response_and_validate_schema(:ok)
+
+      new = Pleroma.Announcement.get_by_id(id)
+
+      assert DateTime.compare(new.starts_at, starts_at) == :eq
+    end
+
+    test "it updates a data field", %{conn: conn} do
+      %{id: id} = announcement = insert(:announcement, data: %{"all_day" => true})
+
+      assert announcement.data["all_day"] == true
+
+      new_content = "new content"
+
+      response =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> patch("/api/v1/pleroma/admin/announcements/#{id}", %{
+          content: new_content
+        })
+        |> json_response_and_validate_schema(:ok)
+
+      assert response["content"] == new_content
+      assert response["all_day"] == true
+
+      new = Pleroma.Announcement.get_by_id(id)
+
+      assert new.data["content"] == new_content
+      assert new.data["all_day"] == true
+    end
+
+    test "it nullifies a nullable field", %{conn: conn} do
+      now = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)
+      starts_at = NaiveDateTime.add(now, -10, :second)
+
+      %{id: id} = insert(:announcement, starts_at: starts_at)
+
+      response =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> patch("/api/v1/pleroma/admin/announcements/#{id}", %{
+          starts_at: nil
+        })
+        |> json_response_and_validate_schema(:ok)
+
+      assert response["starts_at"] == nil
+
+      new = Pleroma.Announcement.get_by_id(id)
+
+      assert new.starts_at == nil
+    end
+  end
+
+  describe "POST /api/v1/pleroma/admin/announcements" do
+    test "it creates an announcement", %{conn: conn} do
+      content = "test post announcement api"
+
+      now = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)
+      starts_at = NaiveDateTime.add(now, -10, :second)
+      ends_at = NaiveDateTime.add(now, 10, :second)
+
+      response =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/pleroma/admin/announcements", %{
+          "content" => content,
+          "starts_at" => NaiveDateTime.to_iso8601(starts_at),
+          "ends_at" => NaiveDateTime.to_iso8601(ends_at),
+          "all_day" => true
+        })
+        |> json_response_and_validate_schema(:ok)
+
+      assert %{"content" => ^content, "all_day" => true} = response
+
+      announcement = Pleroma.Announcement.get_by_id(response["id"])
+
+      assert not is_nil(announcement)
+
+      assert NaiveDateTime.compare(announcement.starts_at, starts_at) == :eq
+      assert NaiveDateTime.compare(announcement.ends_at, ends_at) == :eq
+    end
+
+    test "creating with time with utc timezones", %{conn: conn} do
+      content = "test post announcement api"
+
+      now = DateTime.now("Etc/UTC") |> elem(1) |> DateTime.truncate(:second)
+      starts_at = DateTime.add(now, -10, :second)
+      ends_at = DateTime.add(now, 10, :second)
+
+      response =
+        conn
+        |> put_req_header("content-type", "application/json")
+        |> post("/api/v1/pleroma/admin/announcements", %{
+          "content" => content,
+          "starts_at" => DateTime.to_iso8601(starts_at),
+          "ends_at" => DateTime.to_iso8601(ends_at),
+          "all_day" => true
+        })
+        |> json_response_and_validate_schema(:ok)
+
+      assert %{"content" => ^content, "all_day" => true} = response
+
+      announcement = Pleroma.Announcement.get_by_id(response["id"])
+
+      assert not is_nil(announcement)
+
+      assert DateTime.compare(announcement.starts_at, starts_at) == :eq
+      assert DateTime.compare(announcement.ends_at, ends_at) == :eq
+    end
+  end
+end

test/pleroma/web/mastodon_api/controllers/announcement_controller_test.exs

@@ -0,0 +1,169 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.MastodonAPI.AnnouncementControllerTest do
+  use Pleroma.Web.ConnCase
+
+  import Pleroma.Factory
+
+  alias Pleroma.Announcement
+  alias Pleroma.AnnouncementReadRelationship
+
+  describe "GET /api/v1/announcements" do
+    setup do
+      %{conn: conn} = oauth_access([])
+      {:ok, conn: conn}
+    end
+
+    test "it does not allow guests", %{conn: conn} do
+      _response =
+        conn
+        |> assign(:token, nil)
+        |> get("/api/v1/announcements")
+        |> json_response_and_validate_schema(:forbidden)
+    end
+
+    test "it allows users with scopes" do
+      %{conn: conn} = oauth_access(["read:accounts"])
+
+      _response =
+        conn
+        |> get("/api/v1/announcements")
+        |> json_response_and_validate_schema(:ok)
+    end
+
+    test "it lists all announcements", %{conn: conn} do
+      %{id: id} = insert(:announcement)
+
+      response =
+        conn
+        |> get("/api/v1/announcements")
+        |> json_response_and_validate_schema(:ok)
+
+      assert [%{"id" => ^id}] = response
+    end
+
+    test "it returns time with utc timezone", %{conn: conn} do
+      start_time =
+        NaiveDateTime.utc_now()
+        |> NaiveDateTime.add(-999_999, :second)
+        |> NaiveDateTime.truncate(:second)
+
+      end_time =
+        NaiveDateTime.utc_now()
+        |> NaiveDateTime.add(999_999, :second)
+        |> NaiveDateTime.truncate(:second)
+
+      %{id: id} = insert(:announcement, %{starts_at: start_time, ends_at: end_time})
+
+      response =
+        conn
+        |> get("/api/v1/announcements")
+        |> json_response_and_validate_schema(:ok)
+
+      assert [%{"id" => ^id}] = [announcement] = response
+
+      assert String.ends_with?(announcement["starts_at"], "Z")
+      assert String.ends_with?(announcement["ends_at"], "Z")
+    end
+
+    test "it does not list announcements starting after current time", %{conn: conn} do
+      time = NaiveDateTime.utc_now() |> NaiveDateTime.add(999_999, :second)
+      insert(:announcement, starts_at: time)
+
+      response =
+        conn
+        |> get("/api/v1/announcements")
+        |> json_response_and_validate_schema(:ok)
+
+      assert [] = response
+    end
+
+    test "it does not list announcements ending before current time", %{conn: conn} do
+      time = NaiveDateTime.utc_now() |> NaiveDateTime.add(-999_999, :second)
+      insert(:announcement, ends_at: time)
+
+      response =
+        conn
+        |> get("/api/v1/announcements")
+        |> json_response_and_validate_schema(:ok)
+
+      assert [] = response
+    end
+
+    test "when authenticated, also expose read property", %{conn: conn} do
+      %{id: id} = insert(:announcement)
+
+      response =
+        conn
+        |> get("/api/v1/announcements")
+        |> json_response_and_validate_schema(:ok)
+
+      assert [%{"id" => ^id, "read" => false}] = response
+    end
+
+    test "when authenticated and announcement is read by user" do
+      %{id: id} = announcement = insert(:announcement)
+      user = insert(:user)
+
+      AnnouncementReadRelationship.mark_read(user, announcement)
+
+      %{conn: conn} = oauth_access(["read:accounts"], user: user)
+
+      response =
+        conn
+        |> get("/api/v1/announcements")
+        |> json_response_and_validate_schema(:ok)
+
+      assert [%{"id" => ^id, "read" => true}] = response
+    end
+  end
+
+  describe "POST /api/v1/announcements/:id/dismiss" do
+    setup do: oauth_access(["write:accounts"])
+
+    test "it requires auth", %{conn: conn} do
+      %{id: id} = insert(:announcement)
+
+      _response =
+        conn
+        |> assign(:token, nil)
+        |> post("/api/v1/announcements/#{id}/dismiss")
+        |> json_response_and_validate_schema(:forbidden)
+    end
+
+    test "it requires write:accounts oauth scope" do
+      %{id: id} = insert(:announcement)
+
+      %{conn: conn} = oauth_access(["read:accounts"])
+
+      _response =
+        conn
+        |> post("/api/v1/announcements/#{id}/dismiss")
+        |> json_response_and_validate_schema(:forbidden)
+    end
+
+    test "it gives 404 for non-existent announcements", %{conn: conn} do
+      %{id: id} = insert(:announcement)
+
+      _response =
+        conn
+        |> post("/api/v1/announcements/#{id}xxx/dismiss")
+        |> json_response_and_validate_schema(:not_found)
+    end
+
+    test "it marks announcement as read", %{user: user, conn: conn} do
+      %{id: id} = announcement = insert(:announcement)
+
+      refute Announcement.read_by?(announcement, user)
+
+      _response =
+        conn
+        |> post("/api/v1/announcements/#{id}/dismiss")
+        |> json_response_and_validate_schema(:ok)
+
+      assert Announcement.read_by?(announcement, user)
+    end
+  end
+end

test/support/factory.ex

@@ -627,4 +627,16 @@ def filter_factory do
       context: ["home"]
     }
   end
+
+  def announcement_factory(params \\ %{}) do
+    data = Map.get(params, :data, %{})
+
+    {_, params} = Map.pop(params, :data)
+
+    %Pleroma.Announcement{
+      data: Map.merge(%{"content" => "test announcement", "all_day" => false}, data)
+    }
+    |> Map.merge(params)
+    |> Pleroma.Announcement.add_rendered_properties()
+  end
 end