[WIP] Test transmogrifier

Introduce MobilizonWeb.API namespace Signed-off-by: Thomas Citharel <tcit@tcit.fr> Format Signed-off-by: Thomas Citharel <tcit@tcit.fr> WIP Signed-off-by: Thomas Citharel <tcit@tcit.fr> remove unneeded code Signed-off-by: Thomas Citharel <tcit@tcit.fr> Fix tests Signed-off-by: Thomas Citharel <tcit@tcit.fr> Fix warnings Signed-off-by: Thomas Citharel <tcit@tcit.fr>
2018-12-14 17:41:55 +01:00
parent e3a8343112
commit c1e6612405
41 changed files with 2961 additions and 246 deletions
--- a/lib/mix/tasks/toot.ex
+++ b/lib/mix/tasks/toot.ex
@@ -4,28 +4,12 @@ defmodule Mix.Tasks.Toot do
  """

  use Mix.Task
-  alias Mobilizon.Actors
-  alias Mobilizon.Actors.Actor
-  alias Mobilizon.Service.ActivityPub
-  alias Mobilizon.Service.ActivityPub.Utils
  require Logger

  @shortdoc "Toot to an user"
-  def run([from, to, content]) do
+  def run([from, content]) do
    Mix.Task.run("app.start")

-    with %Actor{} = from <- Actors.get_actor_by_name(from),
-         {:ok, %Actor{} = to} <- ActivityPub.find_or_make_actor_from_nickname(to) do
-      comment = Utils.make_comment_data(from.url, [to.url], content)
-
-      ActivityPub.create(%{
-        to: [to.url],
-        actor: from,
-        object: comment,
-        local: true
-      })
-    else
-      e -> Logger.error(inspect(e))
-    end
+    MobilizonWeb.API.Comments.create_comment(from, content)
  end
 end
--- a/lib/mobilizon/actors/actor.ex
+++ b/lib/mobilizon/actors/actor.ex
@@ -167,6 +167,7 @@ defmodule Mobilizon.Actors.Actor do
    ])
    |> build_urls(:Group)
    |> put_change(:domain, nil)
+    |> put_change(:keys, Actors.create_keys())
    |> put_change(:type, :Group)
    |> validate_required([:url, :outbox_url, :inbox_url, :type, :preferred_username])
    |> unique_constraint(:preferred_username, name: :actors_preferred_username_domain_type_index)
@@ -292,7 +293,7 @@ defmodule Mobilizon.Actors.Actor do
         {:already_following, false} <- {:already_following, following?(follower, followed)} do
      do_follow(follower, followed, approved)
    else
-      {:already_following, _} ->
+      {:already_following, %Follower{}} ->
        {:error,
         "Could not follow actor: you are already following #{followed.preferred_username}"}

@@ -301,6 +302,17 @@ defmodule Mobilizon.Actors.Actor do
    end
  end

+  @spec unfollow(struct(), struct()) :: {:ok, Follower.t()} | {:error, Ecto.Changeset.t()}
+  def unfollow(%Actor{} = followed, %Actor{} = follower) do
+    with {:already_following, %Follower{} = follow} <-
+           {:already_following, following?(follower, followed)} do
+      Actors.delete_follower(follow)
+    else
+      {:already_following, false} ->
+        {:error, "Could not unfollow actor: you are not following #{followed.preferred_username}"}
+    end
+  end
+
  defp do_follow(%Actor{} = follower, %Actor{} = followed, approved) do
    Actors.create_follower(%{
      "actor_id" => follower.id,
@@ -311,12 +323,13 @@ defmodule Mobilizon.Actors.Actor do

  @spec following?(struct(), struct()) :: boolean()
  def following?(
-        %Actor{id: follower_actor_id} = _follower_actor,
-        %Actor{followers: followers} = _followed
+        %Actor{} = follower_actor,
+        %Actor{} = followed_actor
      ) do
-    followers
-    |> Enum.map(& &1.actor_id)
-    |> Enum.member?(follower_actor_id)
+    case Actors.get_follower(followed_actor, follower_actor) do
+      nil -> false
+      %Follower{} = follow -> follow
+    end
  end

  @spec actor_acct_from_actor(struct()) :: String.t()
--- a/lib/mobilizon/actors/actors.ex
+++ b/lib/mobilizon/actors/actors.ex
@@ -162,16 +162,41 @@ defmodule Mobilizon.Actors do
    )
  end

-  def get_group_by_name(name) do
-    case String.split(name, "@") do
-      [name] ->
-        Repo.get_by(Actor, preferred_username: name, type: :Group)
+  @doc """
+  Get a group by it's title
+  """
+  @spec get_group_by_title(String.t()) :: Actor.t() | nil
+  def get_group_by_title(title) do
+    case String.split(title, "@") do
+      [title] ->
+        get_local_group_by_title(title)

-      [name, domain] ->
-        Repo.get_by(Actor, preferred_username: name, domain: domain, type: :Group)
+      [title, domain] ->
+        Repo.one(
+          from(a in Actor,
+            where: a.preferred_username == ^title and a.type == "Group" and a.domain == ^domain
+          )
+        )
    end
  end

+  @doc """
+  Get a local group by it's title
+  """
+  @spec get_local_group_by_title(String.t()) :: Actor.t() | nil
+  def get_local_group_by_title(title) do
+    title
+    |> do_get_local_group_by_title
+    |> Repo.one()
+  end
+
+  @spec do_get_local_group_by_title(String.t()) :: Ecto.Query.t()
+  defp do_get_local_group_by_title(title) do
+    from(a in Actor,
+      where: a.preferred_username == ^title and a.type == "Group" and is_nil(a.domain)
+    )
+  end
+
  @doc """
  Creates a group.

@@ -185,8 +210,6 @@ defmodule Mobilizon.Actors do

  """
  def create_group(attrs \\ %{}) do
-    attrs = Map.put(attrs, :keys, create_keys())
-
    %Actor{}
    |> Actor.group_creation(attrs)
    |> Repo.insert()
@@ -218,10 +241,11 @@ defmodule Mobilizon.Actors do
            keys: data.keys,
            avatar_url: data.avatar_url,
            banner_url: data.banner_url,
-            name: data.name
+            name: data.name,
+            summary: data.summary
          ]
        ],
-        conflict_target: [:preferred_username, :domain, :type]
+        conflict_target: [:url]
      )

    if preload, do: {:ok, Repo.preload(actor, [:followers])}, else: {:ok, actor}
@@ -516,9 +540,11 @@ defmodule Mobilizon.Actors do
    end
  end

-  # Create a new RSA key
+  @doc """
+  Create a new RSA key
+  """
  @spec create_keys() :: String.t()
-  defp create_keys() do
+  def create_keys() do
    key = :public_key.generate_key({:rsa, 2048, 65_537})
    entry = :public_key.pem_entry_encode(:RSAPrivateKey, key)
    [entry] |> :public_key.pem_encode() |> String.trim_trailing()
@@ -958,6 +984,13 @@ defmodule Mobilizon.Actors do
    |> Repo.preload([:actor, :target_actor])
  end

+  @spec get_follower(Actor.t(), Actor.t()) :: Follower.t()
+  def get_follower(%Actor{id: followed_id}, %Actor{id: follower_id}) do
+    Repo.one(
+      from(f in Follower, where: f.target_actor_id == ^followed_id and f.actor_id == ^follower_id)
+    )
+  end
+
  @doc """
  Creates a follower.

@@ -1013,6 +1046,24 @@ defmodule Mobilizon.Actors do
    Repo.delete(follower)
  end

+  @doc """
+  Delete a follower by followed and follower actors
+
+  ## Examples
+
+      iex> delete_follower(%Actor{}, %Actor{})
+      {:ok, %Mobilizon.Actors.Follower{}}
+
+      iex> delete_follower(%Actor{}, %Actor{})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  @spec delete_follower(Actor.t(), Actor.t()) ::
+          {:ok, Follower.t()} | {:error, Ecto.Changeset.t()}
+  def delete_follower(%Actor{} = followed, %Actor{} = follower) do
+    get_follower(followed, follower) |> Repo.delete()
+  end
+
  @doc """
  Returns an `%Ecto.Changeset{}` for tracking follower changes.

--- a/lib/mobilizon/actors/follower.ex
+++ b/lib/mobilizon/actors/follower.ex
@@ -21,4 +21,8 @@ defmodule Mobilizon.Actors.Follower do
    |> validate_required([:score, :approved, :target_actor_id, :actor_id])
    |> unique_constraint(:target_actor_id, name: :followers_actor_target_actor_unique_index)
  end
+
+  def url(%Follower{id: id}) do
+    "#{MobilizonWeb.Endpoint.url()}/follow/#{id}/activity"
+  end
 end
--- a/lib/mobilizon/addresses/addresses.ex
+++ b/lib/mobilizon/addresses/addresses.ex
@@ -116,7 +116,7 @@ defmodule Mobilizon.Addresses do
        rescue
          e in ArgumentError ->
            Logger.error("#{type_input} is not an existing atom : #{inspect(e)}")
-            nil
+            :invalid_type
        end
      else
        type_input
@@ -128,7 +128,7 @@ defmodule Mobilizon.Addresses do
          process_point(data["latitude"], data["longitude"])
      end
    else
-      {:error, nil}
+      {:error, :invalid_type}
    end
  end

--- a/lib/mobilizon/events/events.ex
+++ b/lib/mobilizon/events/events.ex
@@ -117,11 +117,30 @@ defmodule Mobilizon.Events do
    Repo.get_by!(Event, url: url)
  end

+  # @doc """
+  # Gets an event by it's UUID
+  # """
+  # @depreciated "Use get_event_full_by_uuid/3 instead"
+  # def get_event_by_uuid(uuid) do
+  #   Repo.get_by(Event, uuid: uuid)
+  # end
+
  @doc """
-  Gets an event by it's UUID
+  Gets a full event by it's UUID
  """
-  def get_event_by_uuid(uuid) do
-    Repo.get_by(Event, uuid: uuid)
+  @spec get_event_full_by_uuid(String.t()) :: Event.t()
+  def get_event_full_by_uuid(uuid) do
+    event = Repo.get_by(Event, uuid: uuid)
+
+    Repo.preload(event, [
+      :organizer_actor,
+      :category,
+      :sessions,
+      :tracks,
+      :tags,
+      :participants,
+      :physical_address
+    ])
  end

  @doc """
@@ -144,25 +163,31 @@ defmodule Mobilizon.Events do
  @doc """
  Gets an event by it's URL
  """
-  def get_event_full_by_url!(url) do
-    event = Repo.get_by!(Event, url: url)
-
-    Repo.preload(event, [
-      :organizer_actor,
-      :category,
-      :sessions,
-      :tracks,
-      :tags,
-      :participants,
-      :physical_address
-    ])
+  def get_event_full_by_url(url) do
+    case Repo.one(
+           from(e in Event,
+             where: e.url == ^url,
+             preload: [
+               :organizer_actor,
+               :category,
+               :sessions,
+               :tracks,
+               :tags,
+               :participants,
+               :physical_address
+             ]
+           )
+         ) do
+      nil -> {:error, :event_not_found}
+      event -> {:ok, event}
+    end
  end

  @doc """
-  Gets a full event by it's UUID
+  Gets an event by it's URL
  """
-  def get_event_full_by_uuid(uuid) do
-    event = Repo.get_by(Event, uuid: uuid)
+  def get_event_full_by_url!(url) do
+    event = Repo.get_by!(Event, url: url)

    Repo.preload(event, [
      :organizer_actor,
@@ -233,7 +258,7 @@ defmodule Mobilizon.Events do
         {:ok, %Participant{} = _participant} <-
           %Participant{}
           |> Participant.changeset(%{
-             actor_id: attrs.organizer_actor_id,
+             actor_id: event.organizer_actor_id,
             role: 4,
             event_id: event.id
           })
@@ -609,8 +634,12 @@ defmodule Mobilizon.Events do
    Participant.changeset(participant, %{})
  end

-  def list_requests_for_actor(%Actor{} = actor) do
-    Repo.all(from(p in Participant, where: p.actor_id == ^actor.id and p.approved == false))
+  @doc """
+  List event participation requests for an actor
+  """
+  @spec list_requests_for_actor(Actor.t()) :: list(Participant.t())
+  def list_requests_for_actor(%Actor{id: actor_id}) do
+    Repo.all(from(p in Participant, where: p.actor_id == ^actor_id and p.approved == false))
  end

  alias Mobilizon.Events.Session
@@ -631,24 +660,18 @@ defmodule Mobilizon.Events do
  @doc """
  Returns the list of sessions for an event
  """
-  def list_sessions_for_event(event_uuid) do
+  @spec list_sessions_for_event(Event.t()) :: list(Session.t())
+  def list_sessions_for_event(%Event{id: event_id}) do
    Repo.all(
      from(
        s in Session,
        join: e in Event,
        on: s.event_id == e.id,
-        where: e.uuid == ^event_uuid
+        where: e.id == ^event_id
      )
    )
  end

-  @doc """
-  Returns the list of sessions for a track
-  """
-  def list_sessions_for_track(track_id) do
-    Repo.all(from(s in Session, where: s.track_id == ^track_id))
-  end
-
  @doc """
  Gets a single session.

@@ -745,6 +768,14 @@ defmodule Mobilizon.Events do
    Repo.all(Track)
  end

+  @doc """
+  Returns the list of sessions for a track
+  """
+  @spec list_sessions_for_track(Track.t()) :: list(Session.t())
+  def list_sessions_for_track(%Track{id: track_id}) do
+    Repo.all(from(s in Session, where: s.track_id == ^track_id))
+  end
+
  @doc """
  Gets a single track.

@@ -880,9 +911,29 @@ defmodule Mobilizon.Events do
  """
  def get_comment!(id), do: Repo.get!(Comment, id)

-  def get_comment_from_uuid(uuid), do: Repo.get_by(Comment, uuid: uuid)
+  # @doc """
+  # Gets a single comment from it's UUID

-  def get_comment_from_uuid!(uuid), do: Repo.get_by!(Comment, uuid: uuid)
+  # """
+  # @spec get_comment_from_uuid(String.t) :: {:ok, Comment.t} | {:error, nil}
+  # def get_comment_from_uuid(uuid), do: Repo.get_by(Comment, uuid: uuid)
+
+  # @doc """
+  # Gets a single comment by it's UUID.
+
+  # Raises `Ecto.NoResultsError` if the Comment does not exist.
+
+  # ## Examples
+
+  #     iex> get_comment_from_uuid!("123AFV13")
+  #     %Comment{}
+
+  #     iex> get_comment_from_uuid!("20R9HKDJHF")
+  #     ** (Ecto.NoResultsError)
+
+  # """
+  # @spec get_comment_from_uuid(String.t) :: Comment.t
+  # def get_comment_from_uuid!(uuid), do: Repo.get_by!(Comment, uuid: uuid)

  def get_comment_full_from_uuid(uuid) do
    with %Comment{} = comment <- Repo.get_by!(Comment, uuid: uuid) do
@@ -894,9 +945,18 @@ defmodule Mobilizon.Events do

  def get_comment_from_url!(url), do: Repo.get_by!(Comment, url: url)

+  def get_comment_full_from_url(url) do
+    case Repo.one(
+           from(c in Comment, where: c.url == ^url, preload: [:actor, :in_reply_to_comment])
+         ) do
+      nil -> {:error, :comment_not_found}
+      comment -> {:ok, comment}
+    end
+  end
+
  def get_comment_full_from_url!(url) do
    with %Comment{} = comment <- Repo.get_by!(Comment, url: url) do
-      Repo.preload(comment, :actor)
+      Repo.preload(comment, [:actor, :in_reply_to_comment])
    end
  end

--- a/lib/mobilizon_web/api/comments.ex
+++ b/lib/mobilizon_web/api/comments.ex
@@ -0,0 +1,58 @@
+defmodule MobilizonWeb.API.Comments do
+  @moduledoc """
+  API for Comments
+  """
+
+  alias Mobilizon.Actors
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Events.Comment
+  alias Mobilizon.Service.Formatter
+  alias Mobilizon.Service.ActivityPub
+  alias Mobilizon.Service.ActivityPub.Utils, as: ActivityPubUtils
+  import MobilizonWeb.API.Utils
+
+  @doc """
+  Create a comment
+
+  Creates a comment from an actor and a status
+  """
+  @spec create_comment(String.t(), String.t(), String.t()) :: {:ok, Activity.t()} | any()
+  def create_comment(from_username, status, visibility \\ "public", inReplyToCommentURL \\ nil) do
+    with %Actor{url: url} = actor <- Actors.get_local_actor_by_name(from_username),
+         status <- String.trim(status),
+         mentions <- Formatter.parse_mentions(status),
+         inReplyToComment <- get_in_reply_to_comment(inReplyToCommentURL),
+         {to, cc} <- to_for_actor_and_mentions(actor, mentions, inReplyToComment, visibility),
+         tags <- Formatter.parse_tags(status),
+         content_html <-
+           make_content_html(
+             status,
+             mentions,
+             tags,
+             "text/plain"
+           ),
+         comment <-
+           ActivityPubUtils.make_comment_data(
+             url,
+             to,
+             content_html,
+             inReplyToComment,
+             tags,
+             cc
+           ) do
+      ActivityPub.create(%{
+        to: ["https://www.w3.org/ns/activitystreams#Public"],
+        actor: actor,
+        object: comment,
+        local: true
+      })
+    end
+  end
+
+  @spec get_in_reply_to_comment(nil) :: nil
+  defp get_in_reply_to_comment(nil), do: nil
+  @spec get_in_reply_to_comment(String.t()) :: Comment.t()
+  defp get_in_reply_to_comment(inReplyToCommentURL) do
+    ActivityPub.fetch_object_from_url(inReplyToCommentURL)
+  end
+end
--- a/lib/mobilizon_web/api/events.ex
+++ b/lib/mobilizon_web/api/events.ex
@@ -0,0 +1,54 @@
+defmodule MobilizonWeb.API.Events do
+  @moduledoc """
+  API for Events
+  """
+  alias Mobilizon.Actors
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Service.Formatter
+  alias Mobilizon.Service.ActivityPub
+  alias Mobilizon.Service.ActivityPub.Utils, as: ActivityPubUtils
+  import MobilizonWeb.API.Utils
+
+  @spec create_event(map()) :: {:ok, Activity.t()} | any()
+  def create_event(
+        %{
+          title: title,
+          description: description,
+          organizer_actor_username: organizer_actor_username,
+          begins_on: begins_on,
+          category: category
+        } = args
+      ) do
+    with %Actor{url: url} = actor <- Actors.get_local_actor_by_name(organizer_actor_username),
+         title <- String.trim(title),
+         mentions <- Formatter.parse_mentions(description),
+         visibility <- Map.get(args, :visibility, "public"),
+         {to, cc} <- to_for_actor_and_mentions(actor, mentions, nil, visibility),
+         tags <- Formatter.parse_tags(description),
+         content_html <-
+           make_content_html(
+             description,
+             mentions,
+             tags,
+             "text/plain"
+           ),
+         event <-
+           ActivityPubUtils.make_event_data(
+             url,
+             to,
+             title,
+             content_html,
+             tags,
+             cc,
+             %{begins_on: begins_on},
+             category
+           ) do
+      ActivityPub.create(%{
+        to: ["https://www.w3.org/ns/activitystreams#Public"],
+        actor: actor,
+        object: event,
+        local: true
+      })
+    end
+  end
+end
--- a/lib/mobilizon_web/api/groups.ex
+++ b/lib/mobilizon_web/api/groups.ex
@@ -0,0 +1,58 @@
+defmodule MobilizonWeb.API.Groups do
+  @moduledoc """
+  API for Events
+  """
+  alias Mobilizon.Actors
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Service.Formatter
+  alias Mobilizon.Service.ActivityPub
+  alias Mobilizon.Service.ActivityPub.Utils, as: ActivityPubUtils
+  import MobilizonWeb.API.Utils
+
+  @spec create_group(map()) :: {:ok, Activity.t()} | any()
+  def create_group(
+        %{
+          preferred_username: title,
+          description: description,
+          admin_actor_username: admin_actor_username
+        } = args
+      ) do
+    with {:bad_actor, %Actor{url: url} = actor} <-
+           {:bad_actor, Actors.get_local_actor_by_name(admin_actor_username)},
+         {:existing_group, nil} <- {:existing_group, Actors.get_group_by_title(title)},
+         title <- String.trim(title),
+         mentions <- Formatter.parse_mentions(description),
+         visibility <- Map.get(args, :visibility, "public"),
+         {to, cc} <- to_for_actor_and_mentions(actor, mentions, nil, visibility),
+         tags <- Formatter.parse_tags(description),
+         content_html <-
+           make_content_html(
+             description,
+             mentions,
+             tags,
+             "text/plain"
+           ),
+         group <-
+           ActivityPubUtils.make_group_data(
+             url,
+             to,
+             title,
+             content_html,
+             tags,
+             cc
+           ) do
+      ActivityPub.create(%{
+        to: ["https://www.w3.org/ns/activitystreams#Public"],
+        actor: actor,
+        object: group,
+        local: true
+      })
+    else
+      {:existing_group, _} ->
+        {:error, :existing_group_name}
+
+      {:bad_actor} ->
+        {:error, :bad_admin_actor}
+    end
+  end
+end
--- a/lib/mobilizon_web/api/utils.ex
+++ b/lib/mobilizon_web/api/utils.ex
@@ -0,0 +1,123 @@
+defmodule MobilizonWeb.API.Utils do
+  @moduledoc """
+  Utils for API
+  """
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Service.Formatter
+
+  @doc """
+  Determines the full audience based on mentions for a public audience
+
+  Audience is:
+    * `to` : the mentionned actors, the eventual actor we're replying to and the public
+    * `cc` : the actor's followers
+  """
+  @spec to_for_actor_and_mentions(Actor.t(), list(), map(), String.t()) :: {list(), list()}
+  def to_for_actor_and_mentions(%Actor{} = actor, mentions, inReplyTo, "public") do
+    mentioned_actors = Enum.map(mentions, fn {_, %{url: url}} -> url end)
+
+    to = ["https://www.w3.org/ns/activitystreams#Public" | mentioned_actors]
+    cc = [actor.followers_url]
+
+    if inReplyTo do
+      {Enum.uniq([inReplyTo.actor | to]), cc}
+    else
+      {to, cc}
+    end
+  end
+
+  @doc """
+  Determines the full audience based on mentions based on a unlisted audience
+
+  Audience is:
+    * `to` : the mentionned actors, actor's followers and the eventual actor we're replying to
+    * `cc` : public
+  """
+  @spec to_for_actor_and_mentions(Actor.t(), list(), map(), String.t()) :: {list(), list()}
+  def to_for_actor_and_mentions(%Actor{} = actor, mentions, inReplyTo, "unlisted") do
+    mentioned_actors = Enum.map(mentions, fn {_, %{url: url}} -> url end)
+
+    to = [actor.followers_url | mentioned_actors]
+    cc = ["https://www.w3.org/ns/activitystreams#Public"]
+
+    if inReplyTo do
+      {Enum.uniq([inReplyTo.actor | to]), cc}
+    else
+      {to, cc}
+    end
+  end
+
+  @doc """
+  Determines the full audience based on mentions based on a private audience
+
+  Audience is:
+    * `to` : the mentionned actors, actor's followers and the eventual actor we're replying to
+    * `cc` : none
+  """
+  @spec to_for_actor_and_mentions(Actor.t(), list(), map(), String.t()) :: {list(), list()}
+  def to_for_actor_and_mentions(%Actor{} = actor, mentions, inReplyTo, "private") do
+    {to, cc} = to_for_actor_and_mentions(actor, mentions, inReplyTo, "direct")
+    {[actor.followers_url | to], cc}
+  end
+
+  @doc """
+  Determines the full audience based on mentions based on a direct audience
+
+  Audience is:
+    * `to` : the mentionned actors and the eventual actor we're replying to
+    * `cc` : none
+  """
+  @spec to_for_actor_and_mentions(Actor.t(), list(), map(), String.t()) :: {list(), list()}
+  def to_for_actor_and_mentions(_actor, mentions, inReplyTo, "direct") do
+    mentioned_actors = Enum.map(mentions, fn {_, %{url: url}} -> url end)
+
+    if inReplyTo do
+      {Enum.uniq([inReplyTo.actor | mentioned_actors]), []}
+    else
+      {mentioned_actors, []}
+    end
+  end
+
+  @doc """
+  Creates HTML content from text and mentions
+  """
+  @spec make_content_html(String.t(), list(), list(), String.t()) :: String.t()
+  def make_content_html(
+        status,
+        mentions,
+        tags,
+        content_type
+      ),
+      do: format_input(status, mentions, tags, content_type)
+
+  def format_input(text, mentions, tags, "text/plain") do
+    text
+    |> Formatter.html_escape("text/plain")
+    |> String.replace(~r/\r?\n/, "<br>")
+    |> (&{[], &1}).()
+    |> Formatter.add_links()
+    |> Formatter.add_actor_links(mentions)
+    |> Formatter.add_hashtag_links(tags)
+    |> Formatter.finalize()
+  end
+
+  def format_input(text, mentions, _tags, "text/html") do
+    text
+    |> Formatter.html_escape("text/html")
+    |> String.replace(~r/\r?\n/, "<br>")
+    |> (&{[], &1}).()
+    |> Formatter.add_actor_links(mentions)
+    |> Formatter.finalize()
+  end
+
+  def format_input(text, mentions, tags, "text/markdown") do
+    text
+    |> Earmark.as_html!()
+    |> Formatter.html_escape("text/html")
+    |> String.replace(~r/\r?\n/, "")
+    |> (&{[], &1}).()
+    |> Formatter.add_actor_links(mentions)
+    |> Formatter.add_hashtag_links(tags)
+    |> Formatter.finalize()
+  end
+end
--- a/lib/mobilizon_web/resolvers/category.ex
+++ b/lib/mobilizon_web/resolvers/category.ex
@@ -2,6 +2,9 @@ defmodule MobilizonWeb.Resolvers.Category do
  require Logger
  alias Mobilizon.Actors.User

+  ###
+  # TODO : Refactor this into MobilizonWeb.API.Categories when a standard AS category is defined
+  ###
  def list_categories(_parent, %{page: page, limit: limit}, _resolution) do
    categories =
      Mobilizon.Events.list_categories(page, limit)
--- a/lib/mobilizon_web/resolvers/comment.ex
+++ b/lib/mobilizon_web/resolvers/comment.ex
@@ -0,0 +1,25 @@
+defmodule MobilizonWeb.Resolvers.Comment do
+  require Logger
+  alias Mobilizon.Events.Comment
+  alias Mobilizon.Activity
+  alias Mobilizon.Actors.User
+  alias MobilizonWeb.API.Comments
+
+  def create_comment(_parent, %{text: comment, actor_username: username}, %{
+        context: %{current_user: %User{} = _user}
+      }) do
+    with {:ok, %Activity{data: %{"object" => %{"type" => "Note"} = object}}} <-
+           Comments.create_comment(username, comment) do
+      {:ok,
+       %Comment{
+         text: object["content"],
+         url: object["id"],
+         uuid: object["uuid"]
+       }}
+    end
+  end
+
+  def create_comment(_parent, _args, %{}) do
+    {:error, "You are not allowed to create a comment if not connected"}
+  end
+end
--- a/lib/mobilizon_web/resolvers/event.ex
+++ b/lib/mobilizon_web/resolvers/event.ex
@@ -1,6 +1,8 @@
 defmodule MobilizonWeb.Resolvers.Event do
  alias Mobilizon.Service.ActivityPub
+  alias Mobilizon.Activity
  alias Mobilizon.Actors
+  alias Mobilizon.Events.Event

  def list_events(_parent, %{page: page, limit: limit}, _resolution) do
    {:ok, Mobilizon.Events.list_events(page, limit)}
@@ -63,10 +65,27 @@ defmodule MobilizonWeb.Resolvers.Event do
    {:ok, found}
  end

+  @doc """
+  Create an event
+  """
  def create_event(_parent, args, %{context: %{current_user: user}}) do
-    organizer_actor_id = Map.get(args, :organizer_actor_id) || Actors.get_actor_for_user(user).id
-    args = args |> Map.put(:organizer_actor_id, organizer_actor_id)
-    Mobilizon.Events.create_event(args)
+    with {:ok, %Activity{data: %{"object" => %{"type" => "Event"} = object}}} <-
+           args
+           # Set default organizer_actor_id if none set
+           |> Map.update(
+             :organizer_actor_username,
+             Actors.get_actor_for_user(user).preferred_username,
+             & &1
+           )
+           |> MobilizonWeb.API.Events.create_event() do
+      {:ok,
+       %Event{
+         title: object["name"],
+         description: object["content"],
+         uuid: object["uuid"],
+         url: object["id"]
+       }}
+    end
  end

  def create_event(_parent, _args, _resolution) do
--- a/lib/mobilizon_web/resolvers/group.ex
+++ b/lib/mobilizon_web/resolvers/group.ex
@@ -2,6 +2,7 @@ defmodule MobilizonWeb.Resolvers.Group do
  alias Mobilizon.Actors
  alias Mobilizon.Actors.{Actor}
  alias Mobilizon.Service.ActivityPub
+  alias Mobilizon.Activity
  require Logger

  @doc """
@@ -29,24 +30,36 @@ defmodule MobilizonWeb.Resolvers.Group do
  """
  def create_group(
        _parent,
-        %{preferred_username: preferred_username, creator_username: actor_username},
+        args,
        %{
-          context: %{current_user: user}
+          context: %{current_user: _user}
        }
      ) do
-    with %Actor{id: actor_id} <- Actors.get_local_actor_by_name(actor_username),
-         {:user_actor, true} <-
-           {:user_actor, actor_id in Enum.map(Actors.get_actors_for_user(user), & &1.id)},
-         {:ok, %Actor{} = group} <- Actors.create_group(%{preferred_username: preferred_username}) do
-      {:ok, group}
-    else
-      {:error, %Ecto.Changeset{errors: [url: {"has already been taken", []}]}} ->
-        {:error, :group_name_not_available}
-
-      err ->
-        Logger.error(inspect(err))
-        err
+    with {:ok, %Activity{data: %{"object" => %{"type" => "Group"} = object}}} <-
+           MobilizonWeb.API.Groups.create_group(args) do
+      {:ok,
+       %Actor{
+         preferred_username: object["preferredUsername"],
+         summary: object["summary"],
+         type: :Group,
+         #  uuid: object["uuid"],
+         url: object["id"]
+       }}
    end
+
+    # with %Actor{id: actor_id} <- Actors.get_local_actor_by_name(actor_username),
+    #      {:user_actor, true} <-
+    #        {:user_actor, actor_id in Enum.map(Actors.get_actors_for_user(user), & &1.id)},
+    #      {:ok, %Actor{} = group} <- Actors.create_group(%{preferred_username: preferred_username}) do
+    #   {:ok, group}
+    # else
+    #   {:error, %Ecto.Changeset{errors: [url: {"has already been taken", []}]}} ->
+    #     {:error, :group_name_not_available}
+
+    #   err ->
+    #     Logger.error(inspect(err))
+    #     err
+    # end
  end

  def create_group(_parent, _args, _resolution) do
--- a/lib/mobilizon_web/schema.ex
+++ b/lib/mobilizon_web/schema.ex
@@ -253,7 +253,7 @@ defmodule MobilizonWeb.Schema do
    field(:uuid, :uuid)
    field(:url, :string)
    field(:local, :boolean)
-    field(:content, :string)
+    field(:text, :string)
    field(:primaryLanguage, :string)
    field(:replies, list_of(:comment))
    field(:threadLanguages, non_null(list_of(:string)))
@@ -484,12 +484,20 @@ defmodule MobilizonWeb.Schema do
      arg(:address_type, non_null(:address_type))
      arg(:online_address, :string)
      arg(:phone, :string)
-      arg(:organizer_actor_id, non_null(:integer))
-      arg(:category_id, non_null(:integer))
+      arg(:organizer_actor_username, non_null(:string))
+      arg(:category, non_null(:string))

      resolve(&Resolvers.Event.create_event/3)
    end

+    @desc "Create a comment"
+    field :create_comment, type: :comment do
+      arg(:text, non_null(:string))
+      arg(:actor_username, non_null(:string))
+
+      resolve(&Resolvers.Comment.create_comment/3)
+    end
+
    @desc "Create a category with a title, description and picture"
    field :create_category, type: :category do
      arg(:title, non_null(:string))
@@ -552,8 +560,9 @@ defmodule MobilizonWeb.Schema do
    field :create_group, :group do
      arg(:preferred_username, non_null(:string), description: "The name for the group")
      arg(:name, :string, description: "The displayed name for the group")
+      arg(:description, :string, description: "The summary for the group", default_value: "")

-      arg(:creator_username, :string,
+      arg(:admin_actor_username, :string,
        description: "The actor's username which will be the admin (otherwise user's default one)"
      )

--- a/lib/service/activity_pub/activity_pub.ex
+++ b/lib/service/activity_pub/activity_pub.ex
@@ -13,6 +13,7 @@ defmodule Mobilizon.Service.ActivityPub do

  alias Mobilizon.Actors
  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Actors.Follower

  alias Mobilizon.Service.Federator
  alias Mobilizon.Service.HTTPSignatures
@@ -36,7 +37,7 @@ defmodule Mobilizon.Service.ActivityPub do
  @spec insert(map(), boolean()) :: {:ok, %Activity{}} | {:error, any()}
  def insert(map, local \\ true) when is_map(map) do
    with map <- lazy_put_activity_defaults(map),
-         :ok <- insert_full_object(map, local) do
+         :ok <- insert_full_object(map) do
      object_id =
        cond do
          is_map(map["object"]) ->
@@ -46,7 +47,7 @@ defmodule Mobilizon.Service.ActivityPub do
            map["id"]
        end

-      map = Map.put(map, "id", "#{object_id}/activity")
+      map = if local, do: Map.put(map, "id", "#{object_id}/activity"), else: map

      activity = %Activity{
        data: map,
@@ -69,6 +70,8 @@ defmodule Mobilizon.Service.ActivityPub do
  """
  @spec fetch_object_from_url(String.t()) :: {:ok, %Event{}} | {:ok, %Comment{}} | {:error, any()}
  def fetch_object_from_url(url) do
+    Logger.info("Fetching object from url #{url}")
+
    with true <- String.starts_with?(url, "http"),
         nil <- Events.get_event_by_url(url),
         nil <- Events.get_comment_from_url(url),
@@ -94,17 +97,22 @@ defmodule Mobilizon.Service.ActivityPub do
          {:ok, Events.get_event_by_url!(activity.data["object"]["id"])}

        "Note" ->
-          {:ok, Events.get_comment_from_url!(activity.data["object"]["id"])}
+          {:ok, Events.get_comment_full_from_url!(activity.data["object"]["id"])}
+
+        other ->
+          {:error, other}
      end
    else
-      object = %Event{} -> {:ok, object}
-      object = %Comment{} -> {:ok, object}
+      %Event{url: event_url} -> {:ok, Events.get_event_by_url!(event_url)}
+      %Comment{url: comment_url} -> {:ok, Events.get_comment_full_from_url!(comment_url)}
      e -> {:error, e}
    end
  end

  def create(%{to: to, actor: actor, object: object} = params) do
    Logger.debug("creating an activity")
+    Logger.debug(inspect(params))
+    Logger.debug(inspect(object))
    additional = params[:additional] || %{}
    # only accept false as false value
    local = !(params[:local] == false)
@@ -115,6 +123,7 @@ defmodule Mobilizon.Service.ActivityPub do
             %{to: to, actor: actor, published: published, object: object},
             additional
           ),
+         :ok <- Logger.debug(inspect(create_data)),
         {:ok, activity} <- insert(create_data, local),
         :ok <- maybe_federate(activity) do
      # {:ok, actor} <- Actors.increase_event_count(actor) do
@@ -123,6 +132,7 @@ defmodule Mobilizon.Service.ActivityPub do
      err ->
        Logger.error("Something went wrong")
        Logger.error(inspect(err))
+        err
    end
  end

@@ -154,9 +164,82 @@ defmodule Mobilizon.Service.ActivityPub do
    end
  end

-  def follow(%Actor{} = follower, %Actor{} = followed, _activity_id \\ nil, local \\ true) do
-    with {:ok, follow} <- Actor.follow(followed, follower, true),
-         data <- make_follow_data(follower, followed, follow.id),
+  # TODO: This is weird, maybe we shouldn't check here if we can make the activity.
+  # def like(
+  #       %Actor{url: url} = actor,
+  #       object,
+  #       activity_id \\ nil,
+  #       local \\ true
+  #     ) do
+  #   with nil <- get_existing_like(url, object),
+  #        like_data <- make_like_data(user, object, activity_id),
+  #        {:ok, activity} <- insert(like_data, local),
+  #        {:ok, object} <- add_like_to_object(activity, object),
+  #        :ok <- maybe_federate(activity) do
+  #     {:ok, activity, object}
+  #   else
+  #     %Activity{} = activity -> {:ok, activity, object}
+  #     error -> {:error, error}
+  #   end
+  # end
+
+  # def unlike(
+  #       %User{} = actor,
+  #       %Object{} = object,
+  #       activity_id \\ nil,
+  #       local \\ true
+  #     ) do
+  #   with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
+  #        unlike_data <- make_unlike_data(actor, like_activity, activity_id),
+  #        {:ok, unlike_activity} <- insert(unlike_data, local),
+  #        {:ok, _activity} <- Repo.delete(like_activity),
+  #        {:ok, object} <- remove_like_from_object(like_activity, object),
+  #        :ok <- maybe_federate(unlike_activity) do
+  #     {:ok, unlike_activity, like_activity, object}
+  #   else
+  #     _e -> {:ok, object}
+  #   end
+  # end
+
+  # def announce(
+  #       %Actor{} = actor,
+  #       object,
+  #       activity_id \\ nil,
+  #       local \\ true
+  #     ) do
+  #   #with true <- is_public?(object),
+  #        with announce_data <- make_announce_data(actor, object, activity_id),
+  #        {:ok, activity} <- insert(announce_data, local),
+  #       #  {:ok, object} <- add_announce_to_object(activity, object),
+  #        :ok <- maybe_federate(activity) do
+  #     {:ok, activity, object}
+  #   else
+  #     error -> {:error, error}
+  #   end
+  # end
+
+  # def unannounce(
+  #       %Actor{} = actor,
+  #       object,
+  #       activity_id \\ nil,
+  #       local \\ true
+  #     ) do
+  #   with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
+  #        unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
+  #        {:ok, unannounce_activity} <- insert(unannounce_data, local),
+  #        :ok <- maybe_federate(unannounce_activity),
+  #        {:ok, _activity} <- Repo.delete(announce_activity),
+  #        {:ok, object} <- remove_announce_from_object(announce_activity, object) do
+  #     {:ok, unannounce_activity, object}
+  #   else
+  #     _e -> {:ok, object}
+  #   end
+  # end
+
+  def follow(%Actor{} = follower, %Actor{} = followed, activity_id \\ nil, local \\ true) do
+    with {:ok, %Follower{} = follow} <- Actor.follow(followed, follower, true),
+         activity_follow_id <- activity_id || Follower.url(follow),
+         data <- make_follow_data(followed, follower, activity_follow_id),
         {:ok, activity} <- insert(data, local),
         :ok <- maybe_federate(activity) do
      {:ok, activity}
@@ -166,6 +249,23 @@ defmodule Mobilizon.Service.ActivityPub do
    end
  end

+  @spec unfollow(Actor.t(), Actor.t(), String.t(), boolean()) :: {:ok, map()} | any()
+  def unfollow(%Actor{} = followed, %Actor{} = follower, activity_id \\ nil, local \\ true) do
+    with {:ok, %Follower{id: follow_id}} <- Actor.unfollow(followed, follower),
+         # We recreate the follow activity
+         data <- make_follow_data(followed, follower, follow_id),
+         {:ok, follow_activity} <- insert(data, local),
+         unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
+         {:ok, activity} <- insert(unfollow_data, local),
+         :ok <- maybe_federate(activity) do
+      {:ok, activity}
+    else
+      err ->
+        Logger.error(inspect(err))
+        err
+    end
+  end
+
  def delete(object, local \\ true)

  def delete(%Event{url: url, organizer_actor: actor} = event, local) do
@@ -198,6 +298,21 @@ defmodule Mobilizon.Service.ActivityPub do
    end
  end

+  def delete(%Actor{url: url} = actor, local) do
+    data = %{
+      "type" => "Delete",
+      "actor" => url,
+      "object" => url,
+      "to" => [url <> "/followers", "https://www.w3.org/ns/activitystreams#Public"]
+    }
+
+    with Actors.delete_actor(actor),
+         {:ok, activity} <- insert(data, local),
+         :ok <- maybe_federate(activity) do
+      {:ok, activity}
+    end
+  end
+
  @doc """
  Create an actor locally by it's URL (AP ID)
  """
@@ -278,7 +393,7 @@ defmodule Mobilizon.Service.ActivityPub do

  def publish_one(%{inbox: inbox, json: json, actor: actor, id: id}) do
    Logger.info("Federating #{id} to #{inbox}")
-    {host, path} = URI.parse(inbox)
+    %URI{host: host, path: path} = URI.parse(inbox)

    digest = HTTPSignatures.build_digest(json)
    date = HTTPSignatures.generate_date_header()
@@ -333,15 +448,10 @@ defmodule Mobilizon.Service.ActivityPub do
  def actor_data_from_actor_object(data) when is_map(data) do
    actor_data = %{
      url: data["id"],
-      info: %{
-        "ap_enabled" => true,
-        "source_data" => data
-      },
      avatar_url: data["icon"]["url"],
      banner_url: data["image"]["url"],
      name: data["name"],
      preferred_username: data["preferredUsername"],
-      follower_address: data["followers"],
      summary: data["summary"],
      keys: data["publicKey"]["publicKeyPem"],
      inbox_url: data["inbox"],
@@ -416,7 +526,7 @@ defmodule Mobilizon.Service.ActivityPub do

  # Create an activity from a comment
  @spec comment_to_activity(%Comment{}, boolean()) :: Activity.t()
-  defp comment_to_activity(%Comment{} = comment, local \\ true) do
+  def comment_to_activity(%Comment{} = comment, local \\ true) do
    %Activity{
      recipients: ["https://www.w3.org/ns/activitystreams#Public"],
      actor: comment.actor.url,
@@ -471,4 +581,9 @@ defmodule Mobilizon.Service.ActivityPub do
  defp sanitize_ical_event_strings(nil) do
    nil
  end
+
+  def is_public?(activity) do
+    "https://www.w3.org/ns/activitystreams#Public" in (activity.data["to"] ++
+                                                         (activity.data["cc"] || []))
+  end
 end
--- a/lib/service/activity_pub/transmogrifier.ex
+++ b/lib/service/activity_pub/transmogrifier.ex
@@ -2,14 +2,36 @@ defmodule Mobilizon.Service.ActivityPub.Transmogrifier do
  @moduledoc """
  A module to handle coding from internal to wire ActivityPub and back.
  """
-  alias Mobilizon.Actors.Actor
  alias Mobilizon.Actors
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Events
  alias Mobilizon.Events.{Event, Comment}
  alias Mobilizon.Service.ActivityPub
  alias Mobilizon.Service.ActivityPub.Utils

  require Logger

+  def get_actor(%{"actor" => actor}) when is_binary(actor) do
+    actor
+  end
+
+  def get_actor(%{"actor" => actor}) when is_list(actor) do
+    if is_binary(Enum.at(actor, 0)) do
+      Enum.at(actor, 0)
+    else
+      Enum.find(actor, fn %{"type" => type} -> type in ["Person", "Service", "Application"] end)
+      |> Map.get("id")
+    end
+  end
+
+  def get_actor(%{"actor" => %{"id" => id}}) when is_bitstring(id) do
+    id
+  end
+
+  def get_actor(%{"actor" => nil, "attributedTo" => actor}) when not is_nil(actor) do
+    get_actor(%{"actor" => actor})
+  end
+
  @doc """
  Modifies an incoming AP object (mastodon format) to our internal format.
  """
@@ -48,6 +70,10 @@ defmodule Mobilizon.Service.ActivityPub.Transmogrifier do
        object
        |> Map.put("inReplyTo", replied_object.url)

+      {:error, {:error, :not_supported}} ->
+        Logger.info("Object reply origin has not a supported type")
+        object
+
      e ->
        Logger.error("Couldn't fetch #{in_reply_to_id} #{inspect(e)}")
        object
@@ -88,6 +114,7 @@ defmodule Mobilizon.Service.ActivityPub.Transmogrifier do

    with {:ok, %Actor{} = actor} <- Actors.get_or_fetch_by_url(data["actor"]) do
      Logger.debug("found actor")
+      Logger.debug(inspect(actor))

      params = %{
        to: data["to"],
@@ -136,78 +163,134 @@ defmodule Mobilizon.Service.ActivityPub.Transmogrifier do
  #      _e -> :error
  #    end
  #  end
-  #
+  # #
  # def handle_incoming(
  #       %{"type" => "Announce", "object" => object_id, "actor" => actor, "id" => id} = data
  #     ) do
-  #   with {:ok, %Actor{} = actor} <- Actors.get_or_fetch_by_url(actor),
-  #        {:ok, object} <-
-  #          fetch_obj_helper(object_id) || ActivityPub.fetch_object_from_url(object_id),
-  #        {:ok, activity, object} <- ActivityPub.announce(actor, object, id, false) do
+  #   with actor <- get_actor(data),
+  #        {:ok, %Actor{} = actor} <- Actors.get_or_fetch_by_url(actor),
+  #        {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
+  #        {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false) do
+  #     {:ok, activity}
+  #   else
+  #     e -> Logger.error(inspect e)
+  #       :error
+  #   end
+  # end
+
+  def handle_incoming(
+        %{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => _actor_id} =
+          data
+      )
+      when object_type in ["Person", "Application", "Service", "Organization"] do
+    with {:ok, %Actor{url: url}} <- Actors.get_actor_by_url(object["id"]) do
+      {:ok, new_actor_data} = ActivityPub.actor_data_from_actor_object(object)
+
+      Actors.insert_or_update_actor(new_actor_data)
+
+      ActivityPub.update(%{
+        local: false,
+        to: data["to"] || [],
+        cc: data["cc"] || [],
+        object: object,
+        actor: url
+      })
+    else
+      e ->
+        Logger.error(inspect(e))
+        :error
+    end
+  end
+
+  # def handle_incoming(
+  #       %{
+  #         "type" => "Undo",
+  #         "object" => %{"type" => "Announce", "object" => object_id},
+  #         "actor" => actor,
+  #         "id" => id
+  #       } = data
+  #     ) do
+  #   with actor <- get_actor(data),
+  #        {:ok, %Actor{} = actor} <- Actors.get_or_fetch_by_url(actor),
+  #        {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
+  #        {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
  #     {:ok, activity}
  #   else
  #     _e -> :error
  #   end
  # end

-  #
-  #  def handle_incoming(
-  #        %{"type" => "Update", "object" => %{"type" => "Person"} = object, "actor" => actor_id} =
-  #          data
-  #      ) do
-  #    with %User{ap_id: ^actor_id} = actor <- User.get_by_ap_id(object["id"]) do
-  #      {:ok, new_user_data} = ActivityPub.actor_data_from_actor_object(object)
-  #
-  #      banner = new_user_data[:info]["banner"]
-  #
-  #      update_data =
-  #        new_user_data
-  #        |> Map.take([:name, :bio, :avatar])
-  #        |> Map.put(:info, Map.merge(actor.info, %{"banner" => banner}))
-  #
-  #      actor
-  #      |> User.upgrade_changeset(update_data)
-  #      |> User.update_and_set_cache()
-  #
-  #      ActivityPub.update(%{
-  #        local: false,
-  #        to: data["to"] || [],
-  #        cc: data["cc"] || [],
-  #        object: object,
-  #        actor: actor_id
-  #      })
-  #    else
-  #      e ->
-  #        Logger.error(e)
-  #        :error
-  #    end
-  #  end
-  #
-  #  # TODO: Make secure.
-  #  def handle_incoming(
-  #        %{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => id} = data
-  #      ) do
-  #    object_id =
-  #      case object_id do
-  #        %{"id" => id} -> id
-  #        id -> id
-  #      end
-  #
-  #    with %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
-  #         {:ok, object} <-
-  #           fetch_obj_helper(object_id) || ActivityPub.fetch_object_from_id(object_id),
-  #         {:ok, activity} <- ActivityPub.delete(object, false) do
-  #      {:ok, activity}
-  #    else
-  #      e -> :error
-  #    end
-  #  end
+  def handle_incoming(
+        %{
+          "type" => "Undo",
+          "object" => %{"type" => "Follow", "object" => followed},
+          "actor" => follower,
+          "id" => id
+        } = _data
+      ) do
+    with {:ok, %Actor{domain: nil} = followed} <- Actors.get_actor_by_url(followed),
+         {:ok, %Actor{} = follower} <- Actors.get_actor_by_url(follower),
+         {:ok, activity} <- ActivityPub.unfollow(followed, follower, id, false) do
+      Actor.unfollow(follower, followed)
+      {:ok, activity}
+    else
+      e ->
+        Logger.error(inspect(e))
+        :error
+    end
+  end
+
+  # TODO: We presently assume that any actor on the same origin domain as the object being
+  # deleted has the rights to delete that object.  A better way to validate whether or not
+  # the object should be deleted is to refetch the object URI, which should return either
+  # an error or a tombstone.  This would allow us to verify that a deletion actually took
+  # place.
+  def handle_incoming(
+        %{"type" => "Delete", "object" => object, "actor" => _actor, "id" => _id} = data
+      ) do
+    object_id = Utils.get_url(object)
+
+    with actor <- get_actor(data),
+         {:ok, %Actor{url: _actor_url}} <- Actors.get_actor_by_url(actor),
+         {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
+         #  TODO : Validate that DELETE comes indeed form right domain (see above)
+         #  :ok <- contain_origin(actor_url, object.data),
+         {:ok, activity} <- ActivityPub.delete(object, false) do
+      {:ok, activity}
+    else
+      e ->
+        Logger.debug(inspect(e))
+        :error
+    end
+  end
+
  #
  #  # TODO
  #  # Accept
  #  # Undo
  #
-  def handle_incoming(_), do: :error
+  # def handle_incoming(
+  #       %{
+  #         "type" => "Undo",
+  #         "object" => %{"type" => "Like", "object" => object_id},
+  #         "actor" => _actor,
+  #         "id" => id
+  #       } = data
+  #     ) do
+  #   with actor <- get_actor(data),
+  #        %Actor{} = actor <- Actors.get_or_fetch_by_url(actor),
+  #        {:ok, object} <- get_obj_helper(object_id) || fetch_obj_helper(object_id),
+  #        {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
+  #     {:ok, activity}
+  #   else
+  #     _e -> :error
+  #   end
+  # end
+
+  def handle_incoming(_) do
+    Logger.info("Handing something not supported")
+    {:error, :not_supported}
+  end

  def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) do
    with false <- String.starts_with?(in_reply_to, "http"),
@@ -224,7 +307,7 @@ defmodule Mobilizon.Service.ActivityPub.Transmogrifier do
  def prepare_object(object) do
    object
    #    |> set_sensitive
-    #    |> add_hashtags
+    |> add_hashtags
    |> add_mention_tags
    #    |> add_emoji_tags
    |> add_attributed_to
@@ -326,7 +409,13 @@ defmodule Mobilizon.Service.ActivityPub.Transmogrifier do

    mentions =
      recipients
-      |> Enum.map(fn url -> Actors.get_actor_by_url!(url) end)
+      |> Enum.filter(& &1)
+      |> Enum.map(fn url ->
+        case Actors.get_actor_by_url(url) do
+          {:ok, actor} -> actor
+          _ -> nil
+        end
+      end)
      |> Enum.filter(& &1)
      |> Enum.map(fn actor ->
        %{"type" => "Mention", "href" => actor.url, "name" => "@#{actor.preferred_username}"}
@@ -391,4 +480,43 @@ defmodule Mobilizon.Service.ActivityPub.Transmogrifier do

  @spec fetch_obj_helper(map()) :: {:ok, %Event{}} | {:ok, %Comment{}} | {:error, any()}
  def fetch_obj_helper(obj) when is_map(obj), do: ActivityPub.fetch_object_from_url(obj["id"])
+
+  @spec get_obj_helper(String.t()) :: {:ok, struct()} | nil
+  def get_obj_helper(id) do
+    if object = normalize(id), do: {:ok, object}, else: nil
+  end
+
+  @spec normalize(map()) :: struct() | nil
+  def normalize(obj) when is_map(obj), do: get_anything_by_url(obj["id"])
+  @spec normalize(String.t()) :: struct() | nil
+  def normalize(url) when is_binary(url), do: get_anything_by_url(url)
+  @spec normalize(any()) :: nil
+  def normalize(_), do: nil
+
+  @spec normalize(String.t()) :: struct() | nil
+  def get_anything_by_url(url) do
+    Logger.debug("Getting anything from url #{url}")
+    get_actor_url(url) || get_event_url(url) || get_comment_url(url)
+  end
+
+  defp get_actor_url(url) do
+    case Actors.get_actor_by_url(url) do
+      {:ok, %Actor{} = actor} -> actor
+      _ -> nil
+    end
+  end
+
+  defp get_event_url(url) do
+    case Events.get_event_by_url(url) do
+      {:ok, %Event{} = event} -> event
+      _ -> nil
+    end
+  end
+
+  defp get_comment_url(url) do
+    case Events.get_comment_full_from_url(url) do
+      {:ok, %Comment{} = comment} -> comment
+      _ -> nil
+    end
+  end
 end
--- a/lib/service/activity_pub/utils.ex
+++ b/lib/service/activity_pub/utils.ex
@@ -13,11 +13,17 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
  alias Mobilizon.Events
  alias Mobilizon.Activity
  alias Mobilizon.Service.ActivityPub
-  alias Ecto.{Changeset, UUID}
+  alias Ecto.Changeset
  require Logger

-  def make_context(%Activity{data: %{"context" => context}}), do: context
-  def make_context(_), do: generate_context_id()
+  # Some implementations send the actor URI as the actor field, others send the entire actor object,
+  # so figure out what the actor's URI is based on what we have.
+  def get_url(object) do
+    case object do
+      %{"id" => id} -> id
+      id -> id
+    end
+  end

  def make_json_ld_header do
    %{
@@ -38,18 +44,6 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
    DateTime.utc_now() |> DateTime.to_iso8601()
  end

-  def generate_activity_id do
-    generate_id("activities")
-  end
-
-  def generate_context_id do
-    generate_id("contexts")
-  end
-
-  def generate_id(type) do
-    "#{MobilizonWeb.Endpoint.url()}/#{type}/#{UUID.generate()}"
-  end
-
  @doc """
  Enqueues an activity for federation if it's local
  """
@@ -108,16 +102,42 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
  end

  @doc """
-  Inserts a full object if it is contained in an activity.
+  Converts an AP object data to our internal data structure
  """
-  def insert_full_object(object_data, local \\ false)
+  def object_to_event_data(object) do
+    {:ok, %Actor{id: actor_id}} = Actors.get_actor_by_url(object["actor"])
+
+    %{
+      "title" => object["name"],
+      "description" => object["content"],
+      "organizer_actor_id" => actor_id,
+      "begins_on" => object["begins_on"],
+      "category_id" => Events.get_category_by_title(object["category"]).id,
+      "url" => object["id"]
+    }
+  end

  @doc """
  Inserts a full object if it is contained in an activity.
  """
-  def insert_full_object(%{"object" => %{"type" => type} = object_data}, local)
-      when is_map(object_data) and type == "Event" and not local do
-    with {:ok, _} <- Events.create_event(object_data) do
+  def insert_full_object(object_data)
+
+  @doc """
+  Inserts a full object if it is contained in an activity.
+  """
+  def insert_full_object(%{"object" => %{"type" => "Event"} = object_data})
+      when is_map(object_data) do
+    with object_data <- object_to_event_data(object_data),
+         {:ok, _} <- Events.create_event(object_data) do
+      :ok
+    end
+  end
+
+  def insert_full_object(%{"object" => %{"type" => "Group"} = object_data})
+      when is_map(object_data) do
+    with object_data <-
+           Map.put(object_data, "preferred_username", object_data["preferredUsername"]),
+         {:ok, _} <- Actors.create_group(object_data) do
      :ok
    end
  end
@@ -125,8 +145,11 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
  @doc """
  Inserts a full object if it is contained in an activity.
  """
-  def insert_full_object(%{"object" => %{"type" => type} = object_data}, local)
-      when is_map(object_data) and type == "Note" and not local do
+  def insert_full_object(%{"object" => %{"type" => "Note"} = object_data})
+      when is_map(object_data) do
+    Logger.debug("Inserting full comment")
+    Logger.debug(inspect(object_data))
+
    with {:ok, %Actor{id: actor_id}} <- Actors.get_or_fetch_by_url(object_data["actor"]) do
      data = %{
        "text" => object_data["content"],
@@ -134,11 +157,12 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
        "actor_id" => actor_id,
        "in_reply_to_comment_id" => nil,
        "event_id" => nil,
-        "uuid" => object_data["uuid"],
-        "local" => local
+        "uuid" => object_data["uuid"]
      }

      # We fetch the parent object
+      Logger.debug("We're fetching the parent object")
+
      data =
        if Map.has_key?(object_data, "inReplyTo") && object_data["inReplyTo"] != nil &&
             object_data["inReplyTo"] != "" do
@@ -159,7 +183,7 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
              |> Map.put("origin_comment_id", comment |> Comment.get_thread_id())

            # Anthing else is kind of a MP
-            object ->
+            {:error, object} ->
              Logger.debug("Parent object is something we don't handle")
              Logger.debug(inspect(object))
              data
@@ -180,7 +204,7 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
    end
  end

-  def insert_full_object(_, _), do: :ok
+  def insert_full_object(_), do: :ok

  #### Like-related helpers

@@ -206,6 +230,41 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
  #    Repo.one(query)
  #  end

+  @doc """
+  Make an AP event object from an set of values
+  """
+  def make_event_data(
+        actor,
+        to,
+        title,
+        content_html,
+        # attachments,
+        tags \\ [],
+        # _cw \\ nil,
+        cc \\ [],
+        metadata \\ %{},
+        category \\ ""
+      ) do
+    Logger.debug("Making event data")
+    uuid = Ecto.UUID.generate()
+
+    %{
+      "type" => "Event",
+      "to" => to,
+      "cc" => cc,
+      "content" => content_html,
+      "name" => title,
+      # "summary" => cw,
+      # "attachment" => attachments,
+      "begins_on" => metadata.begins_on,
+      "category" => category,
+      "actor" => actor,
+      "id" => "#{MobilizonWeb.Endpoint.url()}/events/#{uuid}",
+      "uuid" => uuid,
+      "tag" => tags |> Enum.map(fn {_, tag} -> tag end) |> Enum.uniq()
+    }
+  end
+
  def make_event_data(
        %Event{title: title, organizer_actor: actor, uuid: uuid},
        to \\ ["https://www.w3.org/ns/activitystreams#Public"]
@@ -238,6 +297,7 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
      "to" => to,
      "content" => text,
      "actor" => actor.url,
+      "attributedTo" => actor.url,
      "uuid" => uuid,
      "id" => "#{MobilizonWeb.Endpoint.url()}/comments/#{uuid}"
    }
@@ -249,14 +309,17 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
    end
  end

+  @doc """
+  Make an AP comment object from an set of values
+  """
  def make_comment_data(
        actor,
        to,
        content_html,
        # attachments,
        inReplyTo \\ nil,
-        # tags,
-        _cw \\ nil,
+        tags \\ [],
+        # _cw \\ nil,
        cc \\ []
      ) do
    Logger.debug("Making comment data")
@@ -271,8 +334,8 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
      # "attachment" => attachments,
      "actor" => actor,
      "id" => "#{MobilizonWeb.Endpoint.url()}/comments/#{uuid}",
-      "uuid" => uuid
-      # "tag" => tags |> Enum.map(fn {_, tag} -> tag end) |> Enum.uniq()
+      "uuid" => uuid,
+      "tag" => tags |> Enum.map(fn {_, tag} -> tag end) |> Enum.uniq()
    }

    if inReplyTo do
@@ -283,19 +346,54 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
    end
  end

-  def make_like_data(%Actor{url: url} = actor, %{data: %{"id" => id}} = object, activity_id) do
-    data = %{
-      "type" => "Like",
-      "actor" => url,
-      "object" => id,
-      "to" => [actor.follower_address, object.data["actor"]],
-      "cc" => ["https://www.w3.org/ns/activitystreams#Public"],
-      "context" => object.data["context"]
-    }
+  def make_group_data(
+        actor,
+        to,
+        preferred_username,
+        content_html,
+        # attachments,
+        tags \\ [],
+        # _cw \\ nil,
+        cc \\ []
+      ) do
+    uuid = Ecto.UUID.generate()

-    if activity_id, do: Map.put(data, "id", activity_id), else: data
+    %{
+      "type" => "Group",
+      "to" => to,
+      "cc" => cc,
+      "summary" => content_html,
+      "attributedTo" => actor,
+      "preferredUsername" => preferred_username,
+      "id" => "#{MobilizonWeb.Endpoint.url()}/~#{preferred_username}",
+      "uuid" => uuid,
+      "tag" => tags |> Enum.map(fn {_, tag} -> tag end) |> Enum.uniq()
+    }
  end

+  #### Like-related helpers
+
+  @doc """
+  Returns an existing like if a user already liked an object
+  """
+  # @spec get_existing_like(Actor.t, map()) :: nil
+  # def get_existing_like(%Actor{url: url} = actor, %{data: %{"id" => id}}) do
+  #   nil
+  # end
+
+  # def make_like_data(%Actor{url: url} = actor, %{data: %{"id" => id}} = object, activity_id) do
+  #   data = %{
+  #     "type" => "Like",
+  #     "actor" => url,
+  #     "object" => id,
+  #     "to" => [actor.followers_url, object.data["actor"]],
+  #     "cc" => ["https://www.w3.org/ns/activitystreams#Public"],
+  #     "context" => object.data["context"]
+  #   }
+
+  #   if activity_id, do: Map.put(data, "id", activity_id), else: data
+  # end
+
  def update_element_in_object(property, element, object) do
    with new_data <-
           object.data
@@ -326,9 +424,9 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
  #### Follow-related helpers

  @doc """
-  Makes a follow activity data for the given follower and followed
+  Makes a follow activity data for the given followed and follower
  """
-  def make_follow_data(%Actor{url: follower_id}, %Actor{url: followed_id}, activity_id) do
+  def make_follow_data(%Actor{url: followed_id}, %Actor{url: follower_id}, activity_id) do
    Logger.debug("Make follow data")

    data = %{
@@ -342,7 +440,7 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
    Logger.debug(inspect(data))

    if activity_id,
-      do: Map.put(data, "id", "#{MobilizonWeb.Endpoint.url()}/follow/#{activity_id}/activity"),
+      do: Map.put(data, "id", activity_id),
      else: data
  end

@@ -352,17 +450,37 @@ defmodule Mobilizon.Service.ActivityPub.Utils do
  Make announce activity data for the given actor and object
  """
  def make_announce_data(
-        %Actor{url: url} = user,
-        %Event{id: id} = object,
+        %Actor{url: actor_url} = actor,
+        %Event{url: event_url} = object,
        activity_id
      ) do
    data = %{
      "type" => "Announce",
-      "actor" => url,
-      "object" => id,
-      "to" => [user.follower_address, object.data["actor"]],
-      "cc" => ["https://www.w3.org/ns/activitystreams#Public"],
-      "context" => object.data["context"]
+      "actor" => actor_url,
+      "object" => event_url,
+      "to" => [actor.followers_url, object.actor.url],
+      "cc" => ["https://www.w3.org/ns/activitystreams#Public"]
+      # "context" => object.data["context"]
+    }
+
+    if activity_id, do: Map.put(data, "id", activity_id), else: data
+  end
+
+  @doc """
+  Make announce activity data for the given actor and object
+  """
+  def make_announce_data(
+        %Actor{url: actor_url} = actor,
+        %Comment{url: comment_url} = object,
+        activity_id
+      ) do
+    data = %{
+      "type" => "Announce",
+      "actor" => actor_url,
+      "object" => comment_url,
+      "to" => [actor.followers_url, object.actor.url],
+      "cc" => ["https://www.w3.org/ns/activitystreams#Public"]
+      # "context" => object.data["context"]
    }

    if activity_id, do: Map.put(data, "id", activity_id), else: data
@@ -376,18 +494,32 @@ defmodule Mobilizon.Service.ActivityPub.Utils do

  #### Unfollow-related helpers

-  def make_unfollow_data(follower, followed, follow_activity) do
-    %{
+  @spec make_unfollow_data(Actor.t(), Actor.t(), map(), String.t()) :: map()
+  def make_unfollow_data(
+        %Actor{url: follower_url},
+        %Actor{url: followed_url},
+        follow_activity,
+        activity_id
+      ) do
+    data = %{
      "type" => "Undo",
-      "actor" => follower.url,
-      "to" => [followed.url],
-      "object" => follow_activity.data["id"]
+      "actor" => follower_url,
+      "to" => [followed_url],
+      "object" => follow_activity.data
    }
+
+    if activity_id, do: Map.put(data, "id", activity_id), else: data
  end

  #### Create-related helpers

+  @doc """
+  Make create activity data
+  """
+  @spec make_create_data(map(), map()) :: map()
  def make_create_data(params, additional \\ %{}) do
+    Logger.debug("Making create data")
+    Logger.debug(inspect(params))
    published = params.published || make_date()

    %{
--- a/lib/service/formatter/formatter.ex
+++ b/lib/service/formatter/formatter.ex
@@ -0,0 +1,157 @@
+defmodule Mobilizon.Service.Formatter do
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Actors
+
+  @tag_regex ~r/\#\w+/u
+  def parse_tags(text, data \\ %{}) do
+    Regex.scan(@tag_regex, text)
+    |> Enum.map(fn ["#" <> tag = full_tag] -> {full_tag, String.downcase(tag)} end)
+    |> (fn map ->
+          if data["sensitive"] in [true, "True", "true", "1"],
+            do: [{"#nsfw", "nsfw"}] ++ map,
+            else: map
+        end).()
+  end
+
+  def parse_mentions(text) do
+    # Modified from https://www.w3.org/TR/html5/forms.html#valid-e-mail-address
+    regex =
+      ~r/@[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]*@?[a-zA-Z0-9_-](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*/u
+
+    Regex.scan(regex, text)
+    |> List.flatten()
+    |> Enum.uniq()
+    |> Enum.map(fn "@" <> match = full_match ->
+      {full_match, Actors.get_actor_by_name(match)}
+    end)
+    |> Enum.filter(fn {_match, user} -> user end)
+  end
+
+  # def emojify(text) do
+  #   emojify(text, Emoji.get_all())
+  # end
+
+  # def emojify(text, nil), do: text
+
+  # def emojify(text, emoji) do
+  #   Enum.reduce(emoji, text, fn {emoji, file}, text ->
+  #     emoji = HTML.strip_tags(emoji)
+  #     file = HTML.strip_tags(file)
+
+  #     String.replace(
+  #       text,
+  #       ":#{emoji}:",
+  #       "<img height='32px' width='32px' alt='#{emoji}' title='#{emoji}' src='#{
+  #         MediaProxy.url(file)
+  #       }' />"
+  #     )
+  #     |> HTML.filter_tags()
+  #   end)
+  # end
+
+  # def get_emoji(text) when is_binary(text) do
+  #   Enum.filter(Emoji.get_all(), fn {emoji, _} -> String.contains?(text, ":#{emoji}:") end)
+  # end
+
+  # def get_emoji(_), do: []
+
+  @link_regex ~r/[0-9a-z+\-\.]+:[0-9a-z$-_.+!*'(),]+/ui
+
+  @uri_schemes Application.get_env(:pleroma, :uri_schemes, [])
+  @valid_schemes Keyword.get(@uri_schemes, :valid_schemes, [])
+
+  # # TODO: make it use something other than @link_regex
+  # def html_escape(text, "text/html") do
+  #   HTML.filter_tags(text)
+  # end
+
+  def html_escape(text, "text/plain") do
+    Regex.split(@link_regex, text, include_captures: true)
+    |> Enum.map_every(2, fn chunk ->
+      {:safe, part} = Phoenix.HTML.html_escape(chunk)
+      part
+    end)
+    |> Enum.join("")
+  end
+
+  @doc "changes scheme:... urls to html links"
+  def add_links({subs, text}) do
+    links =
+      text
+      |> String.split([" ", "\t", "<br>"])
+      |> Enum.filter(fn word -> String.starts_with?(word, @valid_schemes) end)
+      |> Enum.filter(fn word -> Regex.match?(@link_regex, word) end)
+      |> Enum.map(fn url -> {Ecto.UUID.generate(), url} end)
+      |> Enum.sort_by(fn {_, url} -> -String.length(url) end)
+
+    uuid_text =
+      links
+      |> Enum.reduce(text, fn {uuid, url}, acc -> String.replace(acc, url, uuid) end)
+
+    subs =
+      subs ++
+        Enum.map(links, fn {uuid, url} ->
+          {uuid, "<a href=\"#{url}\">#{url}</a>"}
+        end)
+
+    {subs, uuid_text}
+  end
+
+  @doc "Adds the links to mentioned actors"
+  def add_actor_links({subs, text}, mentions) do
+    mentions =
+      mentions
+      |> Enum.sort_by(fn {name, _} -> -String.length(name) end)
+      |> Enum.map(fn {name, actor} -> {name, actor, Ecto.UUID.generate()} end)
+
+    uuid_text =
+      mentions
+      |> Enum.reduce(text, fn {match, _actor, uuid}, text ->
+        String.replace(text, match, uuid)
+      end)
+
+    subs =
+      subs ++
+        Enum.map(mentions, fn {match, %Actor{id: id, url: url}, uuid} ->
+          short_match = String.split(match, "@") |> tl() |> hd()
+
+          {uuid,
+           "<span><a data-user='#{id}' class='mention' href='#{url}'>@<span>#{short_match}</span></a></span>"}
+        end)
+
+    {subs, uuid_text}
+  end
+
+  @doc "Adds the hashtag links"
+  def add_hashtag_links({subs, text}, tags) do
+    tags =
+      tags
+      |> Enum.sort_by(fn {name, _} -> -String.length(name) end)
+      |> Enum.map(fn {name, short} -> {name, short, Ecto.UUID.generate()} end)
+
+    uuid_text =
+      tags
+      |> Enum.reduce(text, fn {match, _short, uuid}, text ->
+        String.replace(text, match, uuid)
+      end)
+
+    subs =
+      subs ++
+        Enum.map(tags, fn {tag_text, tag, uuid} ->
+          url =
+            "<a data-tag='#{tag}' href='#{MobilizonWeb.Endpoint.url()}/tag/#{tag}' rel='tag'>#{
+              tag_text
+            }</a>"
+
+          {uuid, url}
+        end)
+
+    {subs, uuid_text}
+  end
+
+  def finalize({subs, text}) do
+    Enum.reduce(subs, text, fn {uuid, replacement}, result_text ->
+      String.replace(result_text, uuid, replacement)
+    end)
+  end
+end