Rename project to Mobilizon

Signed-off-by: Thomas Citharel <tcit@tcit.fr>

lib/mobilizon_web/controllers/activity_pub_controller.ex

@@ -0,0 +1,132 @@
+defmodule MobilizonWeb.ActivityPubController do
+  use MobilizonWeb, :controller
+  alias Mobilizon.{Actors, Actors.Actor, Events, Events.Event}
+  alias MobilizonWeb.ActivityPub.{ObjectView, ActorView}
+  alias Mobilizon.Service.ActivityPub
+  alias Mobilizon.Service.Federator
+
+  require Logger
+
+  action_fallback(:errors)
+
+  def actor(conn, %{"name" => name}) do
+    with %Actor{} = actor <- Actors.get_local_actor_by_name(name) do
+      case get_req_header(conn, "accept") do
+        ["application/activity+json"] -> 
+          conn
+          |> put_resp_header("content-type", "application/activity+json")
+          |> json(ActorView.render("actor.json", %{actor: actor}))
+        _ ->
+          conn
+          |> put_resp_content_type("text/html")
+          |> send_file(200, "priv/static/index.html")
+      end
+    else
+      nil -> {:error, :not_found}
+    end
+  end
+
+  def event(conn, %{"uuid" => uuid}) do
+    with %Event{} = event <- Events.get_event_full_by_uuid(uuid),
+         true <- event.public do
+      conn
+      |> put_resp_header("content-type", "application/activity+json")
+      |> json(ObjectView.render("event.json", %{event: event}))
+    else
+      false ->
+        {:error, :not_found}
+    end
+  end
+
+  def following(conn, %{"name" => name, "page" => page}) do
+    with %Actor{} = actor <- Actors.get_local_actor_by_name(name) do
+      {page, _} = Integer.parse(page)
+
+      conn
+      |> put_resp_header("content-type", "application/activity+json")
+      |> json(ActorView.render("following.json", %{actor: actor, page: page}))
+    end
+  end
+
+  def following(conn, %{"name" => name}) do
+    with %Actor{} = actor <- Actors.get_local_actor_by_name(name) do
+      conn
+      |> put_resp_header("content-type", "application/activity+json")
+      |> json(ActorView.render("following.json", %{actor: actor}))
+    end
+  end
+
+  def followers(conn, %{"name" => name, "page" => page}) do
+    with %Actor{} = actor <- Actors.get_local_actor_by_name(name) do
+      {page, _} = Integer.parse(page)
+
+      conn
+      |> put_resp_header("content-type", "application/activity+json")
+      |> json(ActorView.render("followers.json", %{actor: actor, page: page}))
+    end
+  end
+
+  def followers(conn, %{"name" => name}) do
+    with %Actor{} = actor <- Actors.get_local_actor_by_name(name) do
+      conn
+      |> put_resp_header("content-type", "application/activity+json")
+      |> json(ActorView.render("followers.json", %{actor: actor}))
+    end
+  end
+
+  def outbox(conn, %{"name" => name, "page" => page}) do
+    with {page, ""} = Integer.parse(page),
+         %Actor{} = actor <- Actors.get_local_actor_by_name(name) do
+      conn
+      |> put_resp_header("content-type", "application/activity+json")
+      |> json(ActorView.render("outbox.json", %{actor: actor, page: page}))
+    end
+  end
+
+  def outbox(conn, %{"name" => username}) do
+    outbox(conn, %{"name" => username, "page" => "0"})
+  end
+
+  # TODO: Ensure that this inbox is a recipient of the message
+  def inbox(%{assigns: %{valid_signature: true}} = conn, params) do
+    Federator.enqueue(:incoming_ap_doc, params)
+    json(conn, "ok")
+  end
+
+  # only accept relayed Creates
+  def inbox(conn, %{"type" => "Create"} = params) do
+    Logger.info(
+      "Signature missing or not from author, relayed Create message, fetching object from source"
+    )
+
+    ActivityPub.fetch_object_from_url(params["object"]["id"])
+
+    json(conn, "ok")
+  end
+
+  def inbox(conn, params) do
+    headers = Enum.into(conn.req_headers, %{})
+
+    if String.contains?(headers["signature"], params["actor"]) do
+      Logger.info(
+        "Signature validation error for: #{params["actor"]}, make sure you are forwarding the HTTP Host header!"
+      )
+
+      Logger.info(inspect(conn.req_headers))
+    end
+
+    json(conn, "error")
+  end
+
+  def errors(conn, {:error, :not_found}) do
+    conn
+    |> put_status(404)
+    |> json("Not found")
+  end
+
+  def errors(conn, _e) do
+    conn
+    |> put_status(500)
+    |> json("error")
+  end
+end

lib/mobilizon_web/controllers/actor_controller.ex

@@ -0,0 +1,79 @@
+defmodule MobilizonWeb.ActorController do
+  @moduledoc """
+  Controller for Actors
+  """
+  use MobilizonWeb, :controller
+
+  alias Mobilizon.Actors
+  alias Mobilizon.Actors.{Actor, User}
+  alias Mobilizon.Service.ActivityPub
+
+  action_fallback(MobilizonWeb.FallbackController)
+
+  def index(conn, _params) do
+    actors = Actors.list_actors()
+    render(conn, "index.json", actors: actors)
+  end
+
+  def create(conn, %{"actor" => actor_params}) do
+    with %User{} = user <- Guardian.Plug.current_resource(conn),
+         actor_params <- Map.put(actor_params, "user_id", user.id),
+         actor_params <- Map.put(actor_params, "keys", keys_for_account()),
+         {:ok, %Actor{} = actor} <- Actors.create_actor(actor_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", actor_path(conn, :show, actor.preferred_username))
+      |> render("show_basic.json", actor: actor)
+    end
+  end
+
+  defp keys_for_account() 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()
+  end
+
+  def show(conn, %{"name" => name}) do
+    with %Actor{} = actor <- Actors.get_actor_by_name_with_everything(name) do
+      render(conn, "show.json", actor: actor)
+    else
+      nil ->
+        send_resp(conn, :not_found, "")
+    end
+  end
+
+  @email_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])?)*$/
+  def search(conn, %{"name" => name}) do
+    # find already saved accounts
+    case Actors.search(name) do
+      {:ok, actors} ->
+        render(conn, "index.json", actors: actors)
+
+      {:error, err} ->
+        json(conn, err)
+    end
+  end
+
+  def update(conn, %{"name" => name, "actor" => actor_params}) do
+    actor = Actors.get_local_actor_by_name(name)
+
+    with {:ok, %Actor{} = actor} <- Actors.update_actor(actor, actor_params) do
+      render(conn, "show_basic.json", actor: actor)
+    end
+  end
+
+  #  def delete(conn, %{"id" => id_str}) do
+  #    {id, _} = Integer.parse(id_str)
+  #    if Guardian.Plug.current_resource(conn).actor.id == id do
+  #      actor = Actors.get_actor!(id)
+  #      with {:ok, %Actor{}} <- Actors.delete_actor(actor) do
+  #        send_resp(conn, :no_content, "")
+  #      end
+  #    else
+  #      send_resp(conn, 401, "")
+  #    end
+  #  end
+end

lib/mobilizon_web/controllers/address_controller.ex

@@ -0,0 +1,78 @@
+defmodule MobilizonWeb.AddressController do
+  @moduledoc """
+  A controller for addresses
+  """
+
+  use MobilizonWeb, :controller
+
+  alias Mobilizon.Addresses
+  alias Mobilizon.Addresses.Address
+
+  action_fallback(MobilizonWeb.FallbackController)
+
+  def index(conn, _params) do
+    addresses = Addresses.list_addresses()
+    render(conn, "index.json", addresses: addresses)
+  end
+
+  def create(conn, %{"address" => address_params}) do
+    with {:ok, geom} <- Addresses.process_geom(address_params["geom"]) do
+      address_params = %{address_params | "geom" => geom}
+
+      with {:ok, %Address{} = address} <- Addresses.create_address(address_params) do
+        conn
+        |> put_status(:created)
+        |> put_resp_header("location", address_path(conn, :show, address))
+        |> render("show.json", address: address)
+      end
+    end
+  end
+
+  def process_geom(%{"type" => type, "data" => data}) do
+    import Logger
+    Logger.debug("Process geom")
+    Logger.debug(inspect(data))
+    Logger.debug(inspect(type))
+    types = [:point]
+
+    unless is_atom(type) do
+      type = String.to_existing_atom(type)
+    end
+
+    case type do
+      :point ->
+        %Geo.Point{coordinates: {data["latitude"], data["longitude"]}, srid: 4326}
+
+      nil ->
+        nil
+    end
+  end
+
+  def process_geom(nil) do
+    nil
+  end
+
+  def show(conn, %{"id" => id}) do
+    address = Addresses.get_address!(id)
+    render(conn, "show.json", address: address)
+  end
+
+  def update(conn, %{"id" => id, "address" => address_params}) do
+    with {:ok, geom} <- Addresses.process_geom(address_params["geom"]) do
+      address = Addresses.get_address!(id)
+      address_params = %{address_params | "geom" => geom}
+
+      with {:ok, %Address{} = address} <- Addresses.update_address(address, address_params) do
+        render(conn, "show.json", address: address)
+      end
+    end
+  end
+
+  def delete(conn, %{"id" => id}) do
+    address = Addresses.get_address!(id)
+
+    with {:ok, %Address{}} <- Addresses.delete_address(address) do
+      send_resp(conn, :no_content, "")
+    end
+  end
+end

lib/mobilizon_web/controllers/bot_controller.ex

@@ -0,0 +1,48 @@
+defmodule MobilizonWeb.BotController do
+  use MobilizonWeb, :controller
+
+  alias Mobilizon.Actors
+  alias Mobilizon.Actors.{Bot, Actor}
+
+  action_fallback(MobilizonWeb.FallbackController)
+
+  def index(conn, _params) do
+    bots = Actors.list_bots()
+    render(conn, "index.json", bots: bots)
+  end
+
+  def create(conn, %{"bot" => bot_params}) do
+    with user <- Guardian.Plug.current_resource(conn),
+         bot_params <- Map.put(bot_params, "user_id", user.id),
+         %Actor{} = actor <-
+           Actors.register_bot_account(%{name: bot_params["name"], summary: bot_params["summary"]}),
+         bot_params <- Map.put(bot_params, "actor_id", actor.id),
+         {:ok, %Bot{} = bot} <- Actors.create_bot(bot_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", bot_path(conn, :show, bot))
+      |> render("show.json", bot: bot)
+    end
+  end
+
+  def show(conn, %{"id" => id}) do
+    bot = Actors.get_bot!(id)
+    render(conn, "show.json", bot: bot)
+  end
+
+  def update(conn, %{"id" => id, "bot" => bot_params}) do
+    bot = Actors.get_bot!(id)
+
+    with {:ok, %Bot{} = bot} <- Actors.update_bot(bot, bot_params) do
+      render(conn, "show.json", bot: bot)
+    end
+  end
+
+  def delete(conn, %{"id" => id}) do
+    bot = Actors.get_bot!(id)
+
+    with {:ok, %Bot{}} <- Actors.delete_bot(bot) do
+      send_resp(conn, :no_content, "")
+    end
+  end
+end

lib/mobilizon_web/controllers/category_controller.ex

@@ -0,0 +1,46 @@
+defmodule MobilizonWeb.CategoryController do
+  @moduledoc """
+  Controller for Categories
+  """
+  use MobilizonWeb, :controller
+
+  alias Mobilizon.Events
+  alias Mobilizon.Events.Category
+
+  action_fallback(MobilizonWeb.FallbackController)
+
+  def index(conn, _params) do
+    categories = Events.list_categories()
+    render(conn, "index.json", categories: categories)
+  end
+
+  def create(conn, %{"category" => category_params}) do
+    with {:ok, %Category{} = category} <- Events.create_category(category_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", category_path(conn, :show, category))
+      |> render("show.json", category: category)
+    end
+  end
+
+  def show(conn, %{"id" => id}) do
+    category = Events.get_category!(id)
+    render(conn, "show.json", category: category)
+  end
+
+  def update(conn, %{"id" => id, "category" => category_params}) do
+    category = Events.get_category!(id)
+
+    with {:ok, %Category{} = category} <- Events.update_category(category, category_params) do
+      render(conn, "show.json", category: category)
+    end
+  end
+
+  def delete(conn, %{"id" => id}) do
+    category = Events.get_category!(id)
+
+    with {:ok, %Category{}} <- Events.delete_category(category) do
+      send_resp(conn, :no_content, "")
+    end
+  end
+end

lib/mobilizon_web/controllers/comment_controller.ex

@@ -0,0 +1,43 @@
+defmodule MobilizonWeb.CommentController do
+  use MobilizonWeb, :controller
+
+  alias Mobilizon.Events
+  alias Mobilizon.Events.Comment
+
+  action_fallback(MobilizonWeb.FallbackController)
+
+  def index(conn, _params) do
+    comments = Events.list_comments()
+    render(conn, "index.json", comments: comments)
+  end
+
+  def create(conn, %{"comment" => comment_params}) do
+    with {:ok, %Comment{} = comment} <- Events.create_comment(comment_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", comment_path(conn, :show, comment))
+      |> render("show.json", comment: comment)
+    end
+  end
+
+  def show(conn, %{"uuid" => uuid}) do
+    comment = Events.get_comment_with_uuid!(uuid)
+    render(conn, "show.json", comment: comment)
+  end
+
+  def update(conn, %{"uuid" => uuid, "comment" => comment_params}) do
+    comment = Events.get_comment_with_uuid!(uuid)
+
+    with {:ok, %Comment{} = comment} <- Events.update_comment(comment, comment_params) do
+      render(conn, "show.json", comment: comment)
+    end
+  end
+
+  def delete(conn, %{"uuid" => uuid}) do
+    comment = Events.get_comment_with_uuid!(uuid)
+
+    with {:ok, %Comment{}} <- Events.delete_comment(comment) do
+      send_resp(conn, :no_content, "")
+    end
+  end
+end

lib/mobilizon_web/controllers/event_controller.ex

@@ -0,0 +1,125 @@
+defmodule MobilizonWeb.EventController do
+  @moduledoc """
+  Controller for Events
+  """
+  use MobilizonWeb, :controller
+
+  alias Mobilizon.Events
+  alias Mobilizon.Events.Event
+  alias Mobilizon.Export.ICalendar
+
+  require Logger
+
+  action_fallback(MobilizonWeb.FallbackController)
+
+  def index(conn, _params) do
+    ip = "88.161.154.97"
+    Logger.debug(inspect(Geolix.lookup(ip), pretty: true))
+
+    with %{
+           city: %Geolix.Adapter.MMDB2.Result.City{
+             city: city,
+             country: country,
+             location: %Geolix.Adapter.MMDB2.Record.Location{
+               latitude: latitude,
+               longitude: longitude
+             }
+           }
+         } <- Geolix.lookup(ip) do
+      distance =
+        case city do
+          nil -> 500_000
+          _ -> 50_000
+        end
+
+      events = Events.find_close_events(longitude, latitude, distance)
+
+      render(
+        conn,
+        "index.json",
+        events: events,
+        coord: %{longitude: longitude, latitude: latitude, distance: distance},
+        city: city,
+        country: country
+      )
+    end
+  end
+
+  def index_all(conn, _params) do
+    events = Events.list_events()
+    render(conn, "index_all.json", events: events)
+  end
+
+  def create(conn, %{"event" => event_params}) do
+    event_params = process_event_address(event_params)
+    Logger.debug("creating event with")
+    Logger.debug(inspect(event_params))
+
+    with {:ok, %Event{} = event} <- Events.create_event(event_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", event_path(conn, :show, event.uuid))
+      |> render("show_simple.json", event: event)
+    end
+  end
+
+  defp process_event_address(event) do
+    cond do
+      Map.has_key?(event, "address_type") && event["address_type"] !== :physical ->
+        event
+
+      Map.has_key?(event, "physical_address") ->
+        address = event["physical_address"]
+        geom = MobilizonWeb.AddressController.process_geom(address["geom"])
+
+        address =
+          case geom do
+            nil ->
+              address
+
+            _ ->
+              %{address | "geom" => geom}
+          end
+
+        %{event | "physical_address" => address}
+
+      true ->
+        event
+    end
+  end
+
+  def search(conn, %{"name" => name}) do
+    events = Events.find_events_by_name(name)
+    render(conn, "index.json", events: events)
+  end
+
+  def show(conn, %{"uuid" => uuid}) do
+    case Events.get_event_full_by_uuid(uuid) do
+      nil ->
+        send_resp(conn, 404, "")
+
+      event ->
+        render(conn, "show.json", event: event)
+    end
+  end
+
+  def export_to_ics(conn, %{"uuid" => uuid}) do
+    event = uuid |> Events.get_event_full_by_uuid() |> ICalendar.export_event()
+    send_resp(conn, 200, event)
+  end
+
+  def update(conn, %{"uuid" => uuid, "event" => event_params}) do
+    event = Events.get_event_full_by_uuid(uuid)
+
+    with {:ok, %Event{} = event} <- Events.update_event(event, event_params) do
+      render(conn, "show_simple.json", event: event)
+    end
+  end
+
+  def delete(conn, %{"uuid" => uuid}) do
+    with event <- Events.get_event_by_uuid(uuid),
+         {:ok, %Event{}} <- Events.delete_event(event) do
+      send_resp(conn, :no_content, "")
+    end
+  end
+end

lib/mobilizon_web/controllers/event_request_controller.ex

@@ -0,0 +1,52 @@
+# defmodule MobilizonWeb.EventRequestController do
+#  @moduledoc """
+#  Controller for Event requests
+#  """
+#  use MobilizonWeb, :controller
+#
+#  alias Mobilizon.Events
+#  alias Mobilizon.Events.{Event, Request}
+#
+#  action_fallback MobilizonWeb.FallbackController
+#
+#  def index_for_user(conn, _params) do
+#    actor = Guardian.Plug.current_resource(conn).actor
+#    requests = Events.list_requests_for_actor(actor)
+#    render(conn, "index.json", requests: requests)
+#  end
+#
+#  def create(conn, %{"request" => request_params}) do
+#    request_params = Map.put(request_params, "actor_id", Guardian.Plug.current_resource(conn).actor.id)
+#    with {:ok, %Request{} = request} <- Events.create_request(request_params) do
+#      conn
+#      |> put_status(:created)
+#      |> put_resp_header("location", event_request_path(conn, :show, request))
+#      |> render("show.json", request: request)
+#    end
+#  end
+#
+#  def create_for_event(conn, %{"request" => request_params, "id" => event_id}) do
+#    request_params = Map.put(request_params, "event_id", event_id)
+#    create(conn, request_params)
+#  end
+#
+#  def show(conn, %{"id" => id}) do
+#    request = Events.get_request!(id)
+#    render(conn, "show.json", request: request)
+#  end
+#
+#  def update(conn, %{"id" => id, "request" => request_params}) do
+#    request = Events.get_request!(id)
+#
+#    with {:ok, %Request{} = request} <- Events.update_request(request, request_params) do
+#      render(conn, "show.json", request: request)
+#    end
+#  end
+#
+#  def delete(conn, %{"id" => id}) do
+#    request = Events.get_request!(id)
+#    with {:ok, %Request{}} <- Events.delete_request(request) do
+#      send_resp(conn, :no_content, "")
+#    end
+#  end
+# end

lib/mobilizon_web/controllers/fallback_controller.ex

@@ -0,0 +1,26 @@
+defmodule MobilizonWeb.FallbackController do
+  @moduledoc """
+  Translates controller action results into valid `Plug.Conn` responses.
+
+  See `Phoenix.Controller.action_fallback/1` for more details.
+  """
+  use MobilizonWeb, :controller
+
+  def call(conn, {:error, %Ecto.Changeset{} = changeset}) do
+    conn
+    |> put_status(:unprocessable_entity)
+    |> render(MobilizonWeb.ChangesetView, "error.json", changeset: changeset)
+  end
+
+  def call(conn, {:error, nil}) do
+    conn
+    |> put_status(:unprocessable_entity)
+    |> render(MobilizonWeb.ErrorView, "invalid_request.json")
+  end
+
+  def call(conn, {:error, :not_found}) do
+    conn
+    |> put_status(:not_found)
+    |> render(MobilizonWeb.ErrorView, :"404")
+  end
+end

lib/mobilizon_web/controllers/follower_controller.ex

@@ -0,0 +1,43 @@
+defmodule MobilizonWeb.FollowerController do
+  use MobilizonWeb, :controller
+
+  alias Mobilizon.Actors
+  alias Mobilizon.Actors.Follower
+
+  action_fallback(MobilizonWeb.FallbackController)
+
+  def index(conn, _params) do
+    followers = Actors.list_followers()
+    render(conn, "index.json", followers: followers)
+  end
+
+  def create(conn, %{"follower" => follower_params}) do
+    with {:ok, %Follower{} = follower} <- Actors.create_follower(follower_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", follower_path(conn, :show, follower))
+      |> render("show.json", follower: follower)
+    end
+  end
+
+  def show(conn, %{"id" => id}) do
+    follower = Actors.get_follower!(id)
+    render(conn, "show.json", follower: follower)
+  end
+
+  def update(conn, %{"id" => id, "follower" => follower_params}) do
+    follower = Actors.get_follower!(id)
+
+    with {:ok, %Follower{} = follower} <- Actors.update_follower(follower, follower_params) do
+      render(conn, "show.json", follower: follower)
+    end
+  end
+
+  def delete(conn, %{"id" => id}) do
+    follower = Actors.get_follower!(id)
+
+    with {:ok, %Follower{}} <- Actors.delete_follower(follower) do
+      send_resp(conn, :no_content, "")
+    end
+  end
+end

lib/mobilizon_web/controllers/group_controller.ex

@@ -0,0 +1,51 @@
+defmodule MobilizonWeb.GroupController do
+  @moduledoc """
+  Controller for Groups
+  """
+  use MobilizonWeb, :controller
+
+  alias Mobilizon.Actors
+  alias Mobilizon.Actors.{Actor, Member}
+
+  action_fallback(MobilizonWeb.FallbackController)
+
+  def index(conn, _params) do
+    groups = Actors.list_groups()
+    render(conn, MobilizonWeb.ActorView, "index.json", actors: groups)
+  end
+
+  def create(conn, %{"group" => group_params}) do
+    with {:ok, %Actor{} = group} <- Actors.create_group(group_params),
+         {:ok, %Member{} = member} <-
+           Actors.create_member(%{
+             "parent_id" => group.id,
+             "actor_id" => Actors.get_local_actor_by_name(group_params["actor_admin"]).id,
+             "role" => 2
+           }) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", actor_path(conn, :show, group))
+      |> render(MobilizonWeb.ActorView, "actor_basic.json", actor: group)
+    end
+  end
+
+  def join(conn, %{"name" => group_name, "actor_name" => actor_name}) do
+    with %Actor{} = group <- Actors.get_group_by_name(group_name),
+         %Actor{} = actor <- Actors.get_local_actor_by_name(actor_name),
+         {:ok, %Member{} = member} <-
+           Actors.create_member(%{"parent_id" => group.id, "actor_id" => actor.id}) do
+      conn
+      |> put_status(:created)
+      |> render(MobilizonWeb.MemberView, "member.json", member: member)
+    else
+      nil ->
+        conn
+        |> put_status(:not_found)
+        |> render(MobilizonWeb.ErrorView, "not_found.json", details: "group or actor doesn't exist")
+
+      err ->
+        require Logger
+        Logger.debug(inspect(err))
+    end
+  end
+end

lib/mobilizon_web/controllers/inboxes_controller.ex

@@ -0,0 +1,6 @@
+defmodule MobilizonWeb.InboxesController do
+  use MobilizonWeb, :controller
+
+  def create(conn) do
+  end
+end

lib/mobilizon_web/controllers/nodeinfo_controller.ex

@@ -0,0 +1,67 @@
+defmodule MobilizonWeb.NodeinfoController do
+  use MobilizonWeb, :controller
+
+  alias MobilizonWeb
+  alias Mobilizon.{Actors, Events}
+
+  @instance Application.get_env(:mobilizon, :instance)
+
+  def schemas(conn, _params) do
+    response = %{
+      links: [
+        %{
+          rel: "http://nodeinfo.diaspora.software/ns/schema/2.0",
+          href: MobilizonWeb.Router.Helpers.nodeinfo_url(MobilizonWeb.Endpoint, :nodeinfo, "2.0")
+        }
+      ]
+    }
+
+    json(conn, response)
+  end
+
+  # Schema definition: https://github.com/jhass/nodeinfo/blob/master/schemas/2.0/schema.json
+  def nodeinfo(conn, %{"version" => "2.0"}) do
+    import Logger
+    Logger.debug(inspect(@instance))
+    # stats = Stats.get_stats()
+
+    response = %{
+      version: "2.0",
+      software: %{
+        name: "mobilizon",
+        version: Keyword.get(@instance, :version)
+      },
+      protocols: ["activitypub"],
+      services: %{
+        inbound: [],
+        outbound: []
+      },
+      openRegistrations: Keyword.get(@instance, :registrations_open),
+      usage: %{
+        users: %{
+          # total: stats.user_count || 0
+          total: Actors.count_users()
+        },
+        localPosts: Events.count_local_events(),
+        localComments: Events.count_local_comments()
+        # localPosts: stats.status_count || 0
+      },
+      metadata: %{
+        nodeName: Keyword.get(@instance, :name)
+      }
+    }
+
+    conn
+    |> put_resp_header(
+      "content-type",
+      "application/json; profile=http://nodeinfo.diaspora.software/ns/schema/2.0#; charset=utf-8"
+    )
+    |> json(response)
+  end
+
+  def nodeinfo(conn, _) do
+    conn
+    |> put_status(404)
+    |> json(%{error: "Nodeinfo schema version not handled"})
+  end
+end

lib/mobilizon_web/controllers/outboxes_controller.ex

@@ -0,0 +1,10 @@
+defmodule MobilizonWeb.OutboxesController do
+  use MobilizonWeb, :controller
+
+  def show(conn) do
+    actor = Guardian.Plug.current_resource(conn).actor
+    events = actor.events
+
+    render(conn, "index.json", events: events)
+  end
+end

lib/mobilizon_web/controllers/page_controller.ex

@@ -0,0 +1,14 @@
+defmodule MobilizonWeb.PageController do
+  @moduledoc """
+  Controller to load our webapp
+  """
+  use MobilizonWeb, :controller
+
+  plug(:put_layout, false)
+
+  def index(conn, _params) do
+    conn
+      |> put_resp_content_type("text/html")
+      |> send_file(200, "priv/static/index.html")
+  end
+end

lib/mobilizon_web/controllers/participant_controller.ex

@@ -0,0 +1,18 @@
+defmodule MobilizonWeb.ParticipantController do
+  @moduledoc """
+  Controller for participants to an event
+  """
+  use MobilizonWeb, :controller
+
+  alias Mobilizon.Events
+
+  def join(conn, %{"uuid" => uuid}) do
+    with event <- Events.get_event_by_uuid(uuid),
+         %{actor: actor} <- Guardian.Plug.current_resource(conn) do
+      participant =
+        Events.create_participant(%{"event_id" => event.id, "actor_id" => actor.id, "role" => 1})
+
+      render(conn, "participant.json", %{participant: participant})
+    end
+  end
+end

lib/mobilizon_web/controllers/search_controller.ex

@@ -0,0 +1,23 @@
+defmodule MobilizonWeb.SearchController do
+  @moduledoc """
+  Controller for Search
+  """
+  use MobilizonWeb, :controller
+
+  alias Mobilizon.Events
+  alias Mobilizon.Actors
+
+  action_fallback(MobilizonWeb.FallbackController)
+
+  def search(conn, %{"name" => name}) do
+    events = Events.find_events_by_name(name)
+    # find already saved accounts
+    case Actors.search(name) do
+      {:ok, actors} ->
+        render(conn, "search.json", events: events, actors: actors)
+
+      {:error, err} ->
+        json(conn, err)
+    end
+  end
+end

lib/mobilizon_web/controllers/session_controller.ex

@@ -0,0 +1,56 @@
+defmodule MobilizonWeb.SessionController do
+  @moduledoc """
+  Controller for (event) Sessions
+  """
+  use MobilizonWeb, :controller
+
+  alias Mobilizon.Events
+  alias Mobilizon.Events.Session
+
+  action_fallback(MobilizonWeb.FallbackController)
+
+  def index(conn, _params) do
+    sessions = Events.list_sessions()
+    render(conn, "index.json", sessions: sessions)
+  end
+
+  def create(conn, %{"session" => session_params}) do
+    with {:ok, %Session{} = session} <- Events.create_session(session_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", session_path(conn, :show, session))
+      |> render("show.json", session: session)
+    end
+  end
+
+  def show(conn, %{"id" => id}) do
+    session = Events.get_session!(id)
+    render(conn, "show.json", session: session)
+  end
+
+  def show_sessions_for_event(conn, %{"uuid" => event_uuid}) do
+    sessions = Events.list_sessions_for_event(event_uuid)
+    render(conn, "index.json", sessions: sessions)
+  end
+
+  def show_sessions_for_track(conn, %{"id" => track}) do
+    sessions = Events.list_sessions_for_track(track)
+    render(conn, "index.json", sessions: sessions)
+  end
+
+  def update(conn, %{"id" => id, "session" => session_params}) do
+    session = Events.get_session!(id)
+
+    with {:ok, %Session{} = session} <- Events.update_session(session, session_params) do
+      render(conn, "show.json", session: session)
+    end
+  end
+
+  def delete(conn, %{"id" => id}) do
+    session = Events.get_session!(id)
+
+    with {:ok, %Session{}} <- Events.delete_session(session) do
+      send_resp(conn, :no_content, "")
+    end
+  end
+end

lib/mobilizon_web/controllers/tag_controller.ex

@@ -0,0 +1,46 @@
+defmodule MobilizonWeb.TagController do
+  @moduledoc """
+  Controller for Tags
+  """
+  use MobilizonWeb, :controller
+
+  alias Mobilizon.Events
+  alias Mobilizon.Events.Tag
+
+  action_fallback(MobilizonWeb.FallbackController)
+
+  def index(conn, _params) do
+    tags = Events.list_tags()
+    render(conn, "index.json", tags: tags)
+  end
+
+  def create(conn, %{"tag" => tag_params}) do
+    with {:ok, %Tag{} = tag} <- Events.create_tag(tag_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", tag_path(conn, :show, tag))
+      |> render("show.json", tag: tag)
+    end
+  end
+
+  def show(conn, %{"id" => id}) do
+    tag = Events.get_tag!(id)
+    render(conn, "show.json", tag: tag)
+  end
+
+  def update(conn, %{"id" => id, "tag" => tag_params}) do
+    tag = Events.get_tag!(id)
+
+    with {:ok, %Tag{} = tag} <- Events.update_tag(tag, tag_params) do
+      render(conn, "show.json", tag: tag)
+    end
+  end
+
+  def delete(conn, %{"id" => id}) do
+    tag = Events.get_tag!(id)
+
+    with {:ok, %Tag{}} <- Events.delete_tag(tag) do
+      send_resp(conn, :no_content, "")
+    end
+  end
+end

lib/mobilizon_web/controllers/track_controller.ex

@@ -0,0 +1,46 @@
+defmodule MobilizonWeb.TrackController do
+  @moduledoc """
+  Controller for Tracks
+  """
+  use MobilizonWeb, :controller
+
+  alias Mobilizon.Events
+  alias Mobilizon.Events.Track
+
+  action_fallback(MobilizonWeb.FallbackController)
+
+  def index(conn, _params) do
+    tracks = Events.list_tracks()
+    render(conn, "index.json", tracks: tracks)
+  end
+
+  def create(conn, %{"track" => track_params}) do
+    with {:ok, %Track{} = track} <- Events.create_track(track_params) do
+      conn
+      |> put_status(:created)
+      |> put_resp_header("location", track_path(conn, :show, track))
+      |> render("show.json", track: track)
+    end
+  end
+
+  def show(conn, %{"id" => id}) do
+    track = Events.get_track!(id)
+    render(conn, "show.json", track: track)
+  end
+
+  def update(conn, %{"id" => id, "track" => track_params}) do
+    track = Events.get_track!(id)
+
+    with {:ok, %Track{} = track} <- Events.update_track(track, track_params) do
+      render(conn, "show.json", track: track)
+    end
+  end
+
+  def delete(conn, %{"id" => id}) do
+    track = Events.get_track!(id)
+
+    with {:ok, %Track{}} <- Events.delete_track(track) do
+      send_resp(conn, :no_content, "")
+    end
+  end
+end

lib/mobilizon_web/controllers/user_controller.ex

@@ -0,0 +1,148 @@
+defmodule MobilizonWeb.UserController do
+  @moduledoc """
+  Controller for Users
+  """
+  use MobilizonWeb, :controller
+
+  alias Mobilizon.Actors
+  alias Mobilizon.Actors.User
+  alias Mobilizon.Repo
+  alias Mobilizon.Actors.Service.{Activation, ResetPassword}
+
+  action_fallback(MobilizonWeb.FallbackController)
+
+  def index(conn, _params) do
+    users = Actors.list_users_with_actors()
+    render(conn, "index.json", users: users)
+  end
+
+  def register(conn, %{"username" => username, "email" => email, "password" => password}) do
+    with {:ok, %User{} = user} <-
+           Actors.register(%{email: email, password: password, username: username}) do
+      Activation.send_confirmation_email(user, "locale")
+
+      conn
+      |> put_status(:created)
+      |> render("confirmation.json", %{user: user})
+    end
+  end
+
+  def validate(conn, %{"token" => token}) do
+    with {:ok, %User{} = user} <- Activation.check_confirmation_token(token) do
+      {:ok, token, _claims} = MobilizonWeb.Guardian.encode_and_sign(user)
+
+      conn
+      |> put_resp_header("location", user_path(conn, :show_current_actor))
+      |> render("show_with_token.json", %{user: user, token: token})
+    else
+      {:error, msg} ->
+        conn
+        |> put_status(:not_found)
+        |> json(%{"error" => msg})
+    end
+  end
+
+  @time_before_resend 3600
+  def resend_confirmation(conn, %{"email" => email}) do
+    with {:ok, %User{} = user} <- Actors.find_by_email(email),
+         false <- is_nil(user.confirmation_token),
+         true <-
+           Timex.before?(
+             Timex.shift(user.confirmation_sent_at, seconds: @time_before_resend),
+             DateTime.utc_now()
+           ) do
+      Activation.resend_confirmation_email(user)
+      render(conn, "confirmation.json", %{user: user})
+    else
+      {:error, :not_found} ->
+        conn
+        |> put_status(:not_found)
+        |> json(%{"error" => "Unable to find an user with this email"})
+
+      _ ->
+        conn
+        |> put_status(:not_found)
+        |> json(%{
+          "error" =>
+            "Unable to resend the validation token. Please wait a while before you can ask for resending token"
+        })
+    end
+  end
+
+  def send_reset_password(conn, %{"email" => email}) do
+    with {:ok, %User{} = user} <- Actors.find_by_email(email),
+         {:ok, _} <- ResetPassword.send_password_reset_email(user) do
+      render(conn, "password_reset.json", %{user: user})
+    else
+      {:error, nil} ->
+        conn
+        |> put_status(:not_found)
+        |> json(%{"errors" => "Unable to find an user with this email"})
+
+      {:error, :email_too_soon} ->
+        conn
+        |> put_status(:not_found)
+        |> json(%{"errors" => "You requested a new reset password too early"})
+    end
+  end
+
+  def reset_password(conn, %{"password" => password, "token" => token}) do
+    with {:ok, %User{} = user} <- ResetPassword.check_reset_password_token(password, token) do
+      {:ok, token, _claims} = MobilizonWeb.Guardian.encode_and_sign(user)
+      render(conn, "show_with_token.json", %{user: user, token: token})
+    else
+      {:error, :invalid_token} ->
+        conn
+        |> put_status(:not_found)
+        |> json(%{"errors" => %{"token" => ["Wrong token for password reset"]}})
+
+      {:error, %Ecto.Changeset{} = changeset} ->
+        conn
+        |> put_status(:unprocessable_entity)
+        |> render(MobilizonWeb.ChangesetView, "error.json", changeset: changeset)
+    end
+  end
+
+  def show_current_actor(conn, _params) do
+    user =
+      conn
+      |> Guardian.Plug.current_resource()
+      |> Repo.preload(:actors)
+
+    render(conn, "show_simple.json", user: user)
+  end
+
+  # defp handle_changeset_errors(errors) do
+  #   errors
+  #   |> Enum.map(fn {field, detail} ->
+  #     "#{field} " <> render_detail(detail)
+  #   end)
+  #   |> Enum.join()
+  # end
+
+  # defp render_detail({message, values}) do
+  #   Enum.reduce(values, message, fn {k, v}, acc ->
+  #     String.replace(acc, "%{#{k}}", to_string(v))
+  #   end)
+  # end
+
+  # defp render_detail(message) do
+  #   message
+  # end
+
+  def update(conn, %{"id" => id, "user" => user_params}) do
+    user = Actors.get_user!(id)
+
+    with {:ok, %User{} = user} <- Actors.update_user(user, user_params) do
+      render(conn, "show.json", user: user)
+    end
+  end
+
+  def delete(conn, %{"id" => id}) do
+    user = Actors.get_user!(id)
+
+    with {:ok, %User{}} <- Actors.delete_user(user) do
+      send_resp(conn, :no_content, "")
+    end
+  end
+end

lib/mobilizon_web/controllers/user_session_controller.ex

@@ -0,0 +1,41 @@
+defmodule MobilizonWeb.UserSessionController do
+  @moduledoc """
+  Controller for user sessions
+  """
+  use MobilizonWeb, :controller
+  alias Mobilizon.Actors.User
+  alias Mobilizon.Actors
+
+  def sign_in(conn, %{"email" => email, "password" => password}) do
+    with {:ok, %User{} = user} <- Actors.find_by_email(email),
+         {:ok, %User{} = _user} <- User.is_confirmed(user),
+         {:ok, token, _claims} <- Actors.authenticate(%{user: user, password: password}) do
+      # Render the token
+      render(conn, "token.json", %{token: token, user: user})
+    else
+      {:error, :not_found} ->
+        conn
+        |> put_status(401)
+        |> json(%{"error_msg" => "No such user", "display_error" => "session.error.bad_login"})
+
+      {:error, :unconfirmed} ->
+        conn
+        |> put_status(401)
+        |> json(%{
+          "error_msg" => "User is not activated",
+          "display_error" => "session.error.not_activated"
+        })
+
+      {:error, :unauthorized} ->
+        conn
+        |> put_status(401)
+        |> json(%{"error_msg" => "Bad login", "display_error" => "session.error.bad_login"})
+    end
+  end
+
+  def sign_out(conn, _params) do
+    conn
+    |> MobilizonWeb.Guardian.Plug.sign_out()
+    |> send_resp(204, "")
+  end
+end

lib/mobilizon_web/controllers/web_finger_controller.ex

@@ -0,0 +1,21 @@
+defmodule MobilizonWeb.WebFingerController do
+  use MobilizonWeb, :controller
+
+  alias Mobilizon.Service.WebFinger
+
+  def host_meta(conn, _params) do
+    xml = WebFinger.host_meta()
+
+    conn
+    |> put_resp_content_type("application/xrd+xml")
+    |> send_resp(200, xml)
+  end
+
+  def webfinger(conn, %{"resource" => resource}) do
+    with {:ok, response} <- WebFinger.webfinger(resource, "JSON") do
+      json(conn, response)
+    else
+      _e -> send_resp(conn, 404, "Couldn't find user")
+    end
+  end
+end