Restructure code base

lib/matrix_server_web/client/account_controller.ex

@@ -0,0 +1,51 @@
+defmodule MatrixServerWeb.Client.AccountController do
+  use MatrixServerWeb, :controller
+
+  import MatrixServer
+  import MatrixServerWeb.Plug.Error
+
+  alias MatrixServer.{Account, Repo}
+  alias Plug.Conn
+
+  def available(conn, params) do
+    localpart = Map.get(params, "username", "")
+
+    case Account.available?(localpart) do
+      :ok ->
+        conn
+        |> put_status(200)
+        |> json(%{available: true})
+
+      {:error, error} ->
+        put_error(conn, error)
+    end
+  end
+
+  def whoami(%Conn{assigns: %{account: %Account{localpart: localpart}}} = conn, _params) do
+    data = %{user_id: get_mxid(localpart)}
+
+    conn
+    |> put_status(200)
+    |> json(data)
+  end
+
+  def logout(%Conn{assigns: %{device: device}} = conn, _params) do
+    case Repo.delete(device) do
+      {:ok, _} ->
+        conn
+        |> put_status(200)
+        |> json(%{})
+
+      {:error, _} ->
+        put_error(conn, :unknown)
+    end
+  end
+
+  def logout_all(%Conn{assigns: %{account: account}} = conn, _params) do
+    Repo.delete_all(Ecto.assoc(account, :devices))
+
+    conn
+    |> put_status(200)
+    |> json(%{})
+  end
+end

lib/matrix_server_web/client/aliases_controller.ex

@@ -0,0 +1,22 @@
+defmodule MatrixServerWeb.Client.AliasesController do
+  use MatrixServerWeb, :controller
+
+  import MatrixServerWeb.Plug.Error
+
+  alias MatrixServer.Alias
+
+  def create(conn, %{"alias" => alias, "room_id" => room_id}) do
+    case Alias.create(alias, room_id) do
+      {:ok, _} ->
+        conn
+        |> put_status(200)
+        |> json(%{})
+
+      {:error, cs} ->
+        put_error(conn, Alias.get_error(cs))
+    end
+  end
+
+  # TODO: create error view for this?
+  def create(conn, _), do: put_error(conn, :bad_json)
+end

lib/matrix_server_web/client/info_controller.ex

@@ -0,0 +1,19 @@
+defmodule MatrixServerWeb.Client.InfoController do
+  use MatrixServerWeb, :controller
+
+  import MatrixServerWeb.Plug.Error
+
+  @supported_versions ["r0.6.1"]
+
+  def versions(conn, _params) do
+    data = %{versions: @supported_versions}
+
+    conn
+    |> put_status(200)
+    |> json(data)
+  end
+
+  def unrecognized(conn, _params) do
+    put_error(conn, :unrecognized)
+  end
+end

lib/matrix_server_web/client/login_controller.ex

@@ -0,0 +1,57 @@
+defmodule MatrixServerWeb.Client.LoginController do
+  use MatrixServerWeb, :controller
+
+  import MatrixServerWeb.Plug.Error
+  import Ecto.Changeset
+
+  alias MatrixServer.{Repo, Account}
+  alias MatrixServerWeb.Request.Login
+  alias Ecto.Changeset
+
+  @login_type "m.login.password"
+
+  def login_types(conn, _params) do
+    data = %{flows: [%{type: @login_type}]}
+
+    conn
+    |> put_status(200)
+    |> json(data)
+  end
+
+  def login(
+        conn,
+        %{"type" => @login_type, "identifier" => %{"type" => "m.id.user"}} = params
+      ) do
+    case Login.changeset(params) do
+      %Changeset{valid?: true} = cs ->
+        input = apply_changes(cs)
+
+        case Account.login(input) |> Repo.transaction() do
+          {:ok, device} ->
+            data = %{
+              user_id: MatrixServer.get_mxid(device.localpart),
+              access_token: device.access_token,
+              device_id: device.device_id
+            }
+
+            conn
+            |> put_status(200)
+            |> json(data)
+
+          {:error, error} when is_atom(error) ->
+            put_error(conn, error)
+
+          {:error, _} ->
+            put_error(conn, :unknown)
+        end
+
+      _ ->
+        put_error(conn, :bad_json)
+    end
+  end
+
+  def login(conn, _params) do
+    # Other login types and identifiers are unsupported for now.
+    put_error(conn, :unrecognized, "Only m.login.password is supported currently.")
+  end
+end

lib/matrix_server_web/client/register_controller.ex

@@ -0,0 +1,60 @@
+defmodule MatrixServerWeb.Client.RegisterController do
+  use MatrixServerWeb, :controller
+
+  import MatrixServerWeb.Plug.Error
+  import Ecto.Changeset
+
+  alias MatrixServer.{Repo, Account}
+  alias MatrixServerWeb.Request.Register
+  alias Ecto.Changeset
+
+  @register_type "m.login.dummy"
+
+  def register(conn, %{"auth" => %{"type" => @register_type}} = params) do
+    case Register.changeset(params) do
+      %Changeset{valid?: true} = cs ->
+        input = apply_changes(cs)
+
+        case Account.register(input) |> Repo.transaction() do
+          {:ok, %{device_with_access_token: device}} ->
+            data = %{user_id: MatrixServer.get_mxid(device.localpart)}
+
+            data =
+              if not input.inhibit_login do
+                data
+                |> Map.put(:device_id, device.device_id)
+                |> Map.put(:access_token, device.access_token)
+              else
+                data
+              end
+
+            conn
+            |> put_status(200)
+            |> json(data)
+
+          {:error, _, cs, _} ->
+            put_error(conn, Register.get_error(cs))
+        end
+
+      _ ->
+        put_error(conn, :bad_json)
+    end
+  end
+
+  def register(conn, %{"auth" => _}) do
+    # Other login types are unsupported for now.
+    put_error(conn, :unrecognized, "Only m.login.dummy is supported currently.")
+  end
+
+  def register(conn, _params) do
+    # User has not started an auth flow.
+    data = %{
+      flows: [%{stages: [@register_type]}],
+      params: %{}
+    }
+
+    conn
+    |> put_status(401)
+    |> json(data)
+  end
+end

lib/matrix_server_web/client/room_controller.ex

@@ -0,0 +1,34 @@
+defmodule MatrixServerWeb.Client.RoomController do
+  use MatrixServerWeb, :controller
+
+  import MatrixServerWeb.Plug.Error
+  import Ecto.Changeset
+
+  alias MatrixServer.Room
+  alias MatrixServerWeb.Request.{CreateRoom}
+  alias Ecto.Changeset
+  alias Plug.Conn
+
+  def create(%Conn{assigns: %{account: account}} = conn, params) do
+    case CreateRoom.changeset(params) do
+      %Changeset{valid?: true} = cs ->
+        input = apply_changes(cs)
+
+        case Room.create(account, input) do
+          {:ok, room_id} ->
+            conn
+            |> put_status(200)
+            |> json(%{room_id: room_id})
+
+          {:error, :authorization} ->
+            put_error(conn, :invalid_room_state)
+
+          {:error, :unknown} ->
+            put_error(conn, :unknown)
+        end
+
+      _ ->
+        put_error(conn, :bad_json)
+    end
+  end
+end