Rename project to Mobilizon

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

lib/mobilizon/activity.ex

@@ -0,0 +1,7 @@
+defmodule Mobilizon.Activity do
+  @moduledoc """
+  Represents an activity
+  """
+
+  defstruct [:id, :data, :local, :actor, :recipients, :notifications, :type]
+end

lib/mobilizon/actors/actor.ex

@@ -0,0 +1,260 @@
+import EctoEnum
+
+defenum(Mobilizon.Actors.ActorTypeEnum, :actor_type, [
+  :Person,
+  :Application,
+  :Group,
+  :Organization,
+  :Service
+])
+
+defmodule Mobilizon.Actors.Actor do
+  @moduledoc """
+  Represents an actor (local and remote actors)
+  """
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Mobilizon.Actors
+  alias Mobilizon.Actors.{Actor, User, Follower, Member}
+  alias Mobilizon.Events.Event
+  alias Mobilizon.Service.ActivityPub
+
+  import Ecto.Query
+  alias Mobilizon.Repo
+
+  import Logger
+
+  #  @type t :: %Actor{description: String.t, id: integer(), inserted_at: DateTime.t, updated_at: DateTime.t, display_name: String.t, domain: String.t, keys: String.t, suspended: boolean(), url: String.t, username: String.t, organized_events: list(), groups: list(), group_request: list(), user: User.t, field: ActorTypeEnum.t}
+
+  schema "actors" do
+    field(:url, :string)
+    field(:outbox_url, :string)
+    field(:inbox_url, :string)
+    field(:following_url, :string)
+    field(:followers_url, :string)
+    field(:shared_inbox_url, :string)
+    field(:type, Mobilizon.Actors.ActorTypeEnum, default: :Person)
+    field(:name, :string)
+    field(:domain, :string)
+    field(:summary, :string)
+    field(:preferred_username, :string)
+    field(:keys, :string)
+    field(:manually_approves_followers, :boolean, default: false)
+    field(:suspended, :boolean, default: false)
+    field(:avatar_url, :string)
+    field(:banner_url, :string)
+    many_to_many(:followers, Actor, join_through: Follower)
+    has_many(:organized_events, Event, foreign_key: :organizer_actor_id)
+    many_to_many(:memberships, Actor, join_through: Member)
+    belongs_to(:user, User)
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(%Actor{} = actor, attrs) do
+    actor
+    |> Ecto.Changeset.cast(attrs, [
+      :url,
+      :outbox_url,
+      :inbox_url,
+      :shared_inbox_url,
+      :following_url,
+      :followers_url,
+      :type,
+      :name,
+      :domain,
+      :summary,
+      :preferred_username,
+      :keys,
+      :manually_approves_followers,
+      :suspended,
+      :avatar_url,
+      :banner_url,
+      :user_id
+    ])
+    |> put_change(:url, "#{MobilizonWeb.Endpoint.url()}/@#{attrs["preferred_username"]}")
+    |> validate_required([:preferred_username, :keys, :suspended, :url])
+    |> unique_constraint(:preferred_username, name: :actors_preferred_username_domain_index)
+  end
+
+  def registration_changeset(%Actor{} = actor, attrs) do
+    actor
+    |> Ecto.Changeset.cast(attrs, [
+      :preferred_username,
+      :domain,
+      :name,
+      :summary,
+      :keys,
+      :keys,
+      :suspended,
+      :url,
+      :type,
+      :avatar_url,
+      :user_id
+    ])
+    |> unique_constraint(:preferred_username, name: :actors_preferred_username_domain_index)
+    |> put_change(:url, "#{MobilizonWeb.Endpoint.url()}/@#{attrs.preferred_username}")
+    |> put_change(:inbox_url, "#{MobilizonWeb.Endpoint.url()}/@#{attrs.preferred_username}/inbox")
+    |> put_change(:outbox_url, "#{MobilizonWeb.Endpoint.url()}/@#{attrs.preferred_username}/outbox")
+    |> put_change(:shared_inbox_url, "#{MobilizonWeb.Endpoint.url()}/inbox")
+    |> validate_required([:preferred_username, :keys, :suspended, :url, :type])
+  end
+
+  # TODO : Use me !
+  @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 remote_actor_creation(params) do
+    changes =
+      %Actor{}
+      |> Ecto.Changeset.cast(params, [
+        :url,
+        :outbox_url,
+        :inbox_url,
+        :shared_inbox_url,
+        :following_url,
+        :followers_url,
+        :type,
+        :name,
+        :domain,
+        :summary,
+        :preferred_username,
+        :keys,
+        :manually_approves_followers,
+        :avatar_url,
+        :banner_url
+      ])
+      |> validate_required([
+        :url,
+        :outbox_url,
+        :inbox_url,
+        :type,
+        :name,
+        :domain,
+        :preferred_username,
+        :keys
+      ])
+      |> unique_constraint(:preferred_username, name: :actors_preferred_username_domain_index)
+      |> validate_length(:summary, max: 5000)
+      |> validate_length(:preferred_username, max: 100)
+      |> put_change(:local, false)
+
+    Logger.debug("Remote actor creation")
+    Logger.debug(inspect(changes))
+    changes
+  end
+
+  def group_creation(%Actor{} = actor, params) do
+    actor
+    |> Ecto.Changeset.cast(params, [
+      :url,
+      :outbox_url,
+      :inbox_url,
+      :shared_inbox_url,
+      :type,
+      :name,
+      :domain,
+      :summary,
+      :preferred_username,
+      :avatar_url,
+      :banner_url
+    ])
+    |> put_change(
+      :outbox_url,
+      "#{MobilizonWeb.Endpoint.url()}/@#{params["preferred_username"]}/outbox"
+    )
+    |> put_change(
+      :inbox_url,
+      "#{MobilizonWeb.Endpoint.url()}/@#{params["preferred_username"]}/inbox"
+    )
+    |> put_change(:shared_inbox_url, "#{MobilizonWeb.Endpoint.url()}/inbox")
+    |> put_change(:url, "#{MobilizonWeb.Endpoint.url()}/@#{params["preferred_username"]}")
+    |> put_change(:domain, nil)
+    |> put_change(:type, :Group)
+    |> validate_required([:url, :outbox_url, :inbox_url, :type, :name, :preferred_username])
+    |> validate_length(:summary, max: 5000)
+    |> validate_length(:preferred_username, max: 100)
+    |> put_change(:local, true)
+  end
+
+  @spec get_public_key_for_url(String.t()) :: {:ok, String.t()}
+  def get_public_key_for_url(url) do
+    with {:ok, %Actor{} = actor} <- Actors.get_or_fetch_by_url(url) do
+      actor.keys
+      |> Mobilizon.Service.ActivityPub.Utils.pem_to_public_key()
+    else
+      _ -> :error
+    end
+  end
+
+  @doc """
+  Get followers from an actor
+
+  If actor A and C both follow actor B, actor B's followers are A and C
+  """
+  def get_followers(%Actor{id: actor_id} = _actor) do
+    Repo.all(
+      from(
+        a in Actor,
+        join: f in Follower,
+        on: a.id == f.actor_id,
+        where: f.target_actor_id == ^actor_id
+      )
+    )
+  end
+
+  @doc """
+  Get followings from an actor
+
+  If actor A follows actor B and C, actor A's followings are B and B
+  """
+  def get_followings(%Actor{id: actor_id} = _actor) do
+    Repo.all(
+      from(
+        a in Actor,
+        join: f in Follower,
+        on: a.id == f.target_actor_id,
+        where: f.actor_id == ^actor_id
+      )
+    )
+  end
+
+  def get_groups_member_of(%Actor{id: actor_id}) do
+    Repo.all(
+      from(
+        a in Actor,
+        join: m in Member,
+        on: a.id == m.parent_id,
+        where: m.actor_id == ^actor_id
+      )
+    )
+  end
+
+  def get_members_for_group(%Actor{id: actor_id}) do
+    Repo.all(
+      from(
+        a in Actor,
+        join: m in Member,
+        on: a.id == m.actor_id,
+        where: m.parent_id == ^actor_id
+      )
+    )
+  end
+
+  def follow(%Actor{} = follower, %Actor{} = followed) do
+    # Check if actor is locked
+    # Check if followed has blocked follower
+    # Check if follower already follows followed
+    cond do
+      following?(follower, followed) ->
+        {:error,
+         "Could not follow actor: you are already following #{followed.preferred_username}"}
+
+        # true -> nil
+        # Follow the person
+    end
+  end
+
+  def following?(%Actor{} = follower, %Actor{followers: followers}) do
+    Enum.member?(followers, follower)
+  end
+end

lib/mobilizon/actors/actors.ex

@@ -0,0 +1,815 @@
+defmodule Mobilizon.Actors do
+  @moduledoc """
+  The Actors context.
+  """
+
+  import Ecto.Query, warn: false
+  alias Mobilizon.Repo
+
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Actors
+
+  alias Mobilizon.Service.ActivityPub
+
+  @doc """
+  Returns the list of actors.
+
+  ## Examples
+
+      iex> list_actors()
+      [%Actor{}, ...]
+
+  """
+  def list_actors do
+    Repo.all(Actor)
+  end
+
+  @doc """
+  Gets a single actor.
+
+  Raises `Ecto.NoResultsError` if the Actor does not exist.
+
+  ## Examples
+
+      iex> get_actor!(123)
+      %Actor{}
+
+      iex> get_actor!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_actor!(id) do
+    Repo.get!(Actor, id)
+  end
+
+  def get_actor_with_everything!(id) do
+    actor = Repo.get!(Actor, id)
+    Repo.preload(actor, :organized_events)
+  end
+
+  @doc """
+  Creates a actor.
+
+  ## Examples
+
+      iex> create_actor(%{field: value})
+      {:ok, %Actor{}}
+
+      iex> create_actor(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_actor(attrs \\ %{}) do
+    %Actor{}
+    |> Actor.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a actor.
+
+  ## Examples
+
+      iex> update_actor(actor, %{field: new_value})
+      {:ok, %Actor{}}
+
+      iex> update_actor(actor, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_actor(%Actor{} = actor, attrs) do
+    actor
+    |> Actor.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a Actor.
+
+  ## Examples
+
+      iex> delete_actor(actor)
+      {:ok, %Actor{}}
+
+      iex> delete_actor(actor)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_actor(%Actor{} = actor) do
+    Repo.delete(actor)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking actor changes.
+
+  ## Examples
+
+      iex> change_actor(actor)
+      %Ecto.Changeset{source: %Actor{}}
+
+  """
+  def change_actor(%Actor{} = actor) do
+    Actor.changeset(actor, %{})
+  end
+
+  @doc """
+  List the groups
+  """
+  def list_groups do
+    Repo.all(from(a in Actor, where: a.type == ^:Group))
+  end
+
+  def get_group_by_name(name) do
+    case String.split(name, "@") do
+      [name] ->
+        Repo.get_by(Actor, preferred_username: name, type: :Group)
+
+      [name, domain] ->
+        Repo.get_by(Actor, preferred_username: name, domain: domain, type: :Group)
+    end
+  end
+
+  @doc """
+  Creates a group.
+
+  ## Examples
+
+      iex> create_group(%{field: value})
+      {:ok, %Actor{}}
+
+      iex> create_group(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_group(attrs \\ %{}) do
+    %Actor{}
+    |> Actor.group_creation(attrs)
+    |> Repo.insert()
+  end
+
+  alias Mobilizon.Actors.User
+
+  @doc """
+  Returns the list of users.
+
+  ## Examples
+
+      iex> list_users()
+      [%User{}, ...]
+
+  """
+  def list_users do
+    Repo.all(User)
+  end
+
+  def list_users_with_actors do
+    users = Repo.all(User)
+    Repo.preload(users, :actors)
+  end
+
+  defp blank?(""), do: nil
+  defp blank?(n), do: n
+
+  def insert_or_update_actor(data) do
+    cs = Actor.remote_actor_creation(data)
+
+    Repo.insert(
+      cs,
+      on_conflict: [
+        set: [
+          keys: data.keys,
+          avatar_url: data.avatar_url,
+          banner_url: data.banner_url,
+          name: data.name
+        ]
+      ],
+      conflict_target: [:preferred_username, :domain]
+    )
+  end
+
+  #  def increase_event_count(%Actor{} = actor) do
+  #    event_count = (actor.info["event_count"] || 0) + 1
+  #    new_info = Map.put(actor.info, "note_count", note_count)
+  #
+  #    cs = info_changeset(actor, %{info: new_info})
+  #
+  #    update_and_set_cache(cs)
+  #  end
+
+  def count_users() do
+    Repo.one(
+      from(
+        u in User,
+        select: count(u.id)
+      )
+    )
+  end
+
+  @doc """
+  Gets a single user.
+
+  Raises `Ecto.NoResultsError` if the User does not exist.
+
+  ## Examples
+
+      iex> get_user!(123)
+      %User{}
+
+      iex> get_user!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_user!(id), do: Repo.get!(User, id)
+
+  def get_user_with_actor!(id) do
+    user = Repo.get!(User, id)
+    Repo.preload(user, :actors)
+  end
+
+  def get_actor_by_url(url) do
+    Repo.get_by(Actor, url: url)
+  end
+
+  def get_actor_by_name(name) do
+    actor =
+      case String.split(name, "@") do
+        [name] ->
+          Repo.get_by(Actor, preferred_username: name)
+
+        [name, domain] ->
+          Repo.get_by(Actor, preferred_username: name, domain: domain)
+      end
+  end
+
+  def get_local_actor_by_name(name) do
+    Repo.one(from(a in Actor, where: a.preferred_username == ^name and is_nil(a.domain)))
+  end
+
+  def get_local_actor_by_name_with_everything(name) do
+    actor = Repo.one(from(a in Actor, where: a.preferred_username == ^name and is_nil(a.domain)))
+    Repo.preload(actor, :organized_events)
+  end
+
+  def get_actor_by_name_with_everything(name) do
+    actor =
+      case String.split(name, "@") do
+        [name] ->
+          Repo.one(from(a in Actor, where: a.preferred_username == ^name and is_nil(a.domain)))
+
+        [name, domain] ->
+          Repo.one(from(a in Actor, where: a.preferred_username == ^name and a.domain == ^domain))
+      end
+
+    Repo.preload(actor, :organized_events)
+  end
+
+  def get_or_fetch_by_url(url) do
+    if actor = get_actor_by_url(url) do
+      {:ok, actor}
+    else
+      case ActivityPub.make_actor_from_url(url) do
+        {:ok, actor} ->
+          {:ok, actor}
+
+        _ ->
+          {:error, "Could not fetch by AP id"}
+      end
+    end
+  end
+
+  @doc """
+  Find local users by it's username
+  """
+  def find_local_by_username(username) do
+    actors =
+      Repo.all(
+        from(
+          a in Actor,
+          where:
+            (ilike(a.preferred_username, ^like_sanitize(username)) or
+               ilike(a.name, ^like_sanitize(username))) and is_nil(a.domain)
+        )
+      )
+
+    Repo.preload(actors, :organized_events)
+  end
+
+  @doc """
+  Find actors by their name or displayed name
+  """
+  def find_actors_by_username_or_name(username) do
+    Repo.all(
+      from(
+        a in Actor,
+        where:
+          ilike(a.preferred_username, ^like_sanitize(username)) or
+            ilike(a.name, ^like_sanitize(username))
+      )
+    )
+  end
+
+  @doc """
+  Sanitize the LIKE queries
+  """
+  defp like_sanitize(value) do
+    "%" <> String.replace(value, ~r/([\\%_])/, "\\1") <> "%"
+  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(name) do
+    # find already saved accounts
+    case find_actors_by_username_or_name(name) do
+      [] ->
+        # no accounts found, let's test if it's an username@domain.tld
+        with true <- Regex.match?(@email_regex, name),
+             # creating the actor in that case
+             {:ok, actor} <- ActivityPub.find_or_make_actor_from_nickname(name) do
+          {:ok, [actor]}
+        else
+          false ->
+            {:ok, []}
+
+          # error fingering the actor
+          {:error, err} ->
+            {:error, err}
+        end
+
+      actors = [_ | _] ->
+        # actors already saved found !
+        {:ok, actors}
+    end
+  end
+
+  @doc """
+  Get an user by email
+  """
+  def find_by_email(email) do
+    case Repo.preload(Repo.get_by(User, email: email), :actors) do
+      nil ->
+        {:error, nil}
+
+      user ->
+        {:ok, user}
+    end
+  end
+
+  @doc """
+  Authenticate user
+  """
+  def authenticate(%{user: user, password: password}) do
+    # Does password match the one stored in the database?
+    case Comeonin.Argon2.checkpw(password, user.password_hash) do
+      true ->
+        # Yes, create and return the token
+        MobilizonWeb.Guardian.encode_and_sign(user)
+
+      _ ->
+        # No, return an error
+        {:error, :unauthorized}
+    end
+  end
+
+  @doc """
+  Register user
+  """
+  def register(%{email: email, password: password, username: username}) do
+    key = :public_key.generate_key({:rsa, 2048, 65_537})
+    entry = :public_key.pem_entry_encode(:RSAPrivateKey, key)
+    pem = [entry] |> :public_key.pem_encode() |> String.trim_trailing()
+
+    import Exgravatar
+
+    avatar_url = gravatar_url(email, default: "404")
+
+    avatar =
+      case HTTPoison.get(avatar_url) do
+        {:ok, %HTTPoison.Response{status_code: 200}} ->
+          avatar_url
+
+        _ ->
+          nil
+      end
+
+    actor =
+      Mobilizon.Actors.Actor.registration_changeset(%Mobilizon.Actors.Actor{}, %{
+        preferred_username: username,
+        domain: nil,
+        keys: pem,
+        avatar_url: avatar
+      })
+
+    user =
+      Mobilizon.Actors.User.registration_changeset(%Mobilizon.Actors.User{}, %{
+        email: email,
+        password: password
+      })
+
+    actor_with_user = Ecto.Changeset.put_assoc(actor, :user, user)
+
+    try do
+      Mobilizon.Repo.insert!(actor_with_user)
+      find_by_email(email)
+    rescue
+      e in Ecto.InvalidChangesetError ->
+        {:error, e.changeset}
+    end
+  end
+
+  def register_bot_account(%{name: name, summary: summary}) do
+    key = :public_key.generate_key({:rsa, 2048, 65_537})
+    entry = :public_key.pem_entry_encode(:RSAPrivateKey, key)
+    pem = [entry] |> :public_key.pem_encode() |> String.trim_trailing()
+
+    actor =
+      Mobilizon.Actors.Actor.registration_changeset(%Mobilizon.Actors.Actor{}, %{
+        preferred_username: name,
+        domain: nil,
+        keys: pem,
+        summary: summary,
+        type: :Service
+      })
+
+    try do
+      Mobilizon.Repo.insert!(actor)
+    rescue
+      e in Ecto.InvalidChangesetError ->
+        {:error, e.changeset}
+    end
+  end
+
+  @doc """
+  Creates a user.
+
+  ## Examples
+
+      iex> create_user(%{field: value})
+      {:ok, %User{}}
+
+      iex> create_user(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_user(attrs \\ %{}) do
+    %User{}
+    |> User.registration_changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Gets an user by it's email
+
+  ## Examples
+
+      iex> get_user_by_email(user, email)
+      {:ok, %User{}}
+
+      iex> get_user_by_email(user, wrong_email)
+      {:error, nil}
+  """
+  def get_user_by_email(email) do
+    case Repo.get_by(User, email: email) do
+      nil -> {:error, nil}
+      user -> {:ok, user}
+    end
+  end
+
+  @doc """
+  Updates a user.
+
+  ## Examples
+
+      iex> update_user(user, %{field: new_value})
+      {:ok, %User{}}
+
+      iex> update_user(user, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_user(%User{} = user, attrs) do
+    user
+    |> User.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a User.
+
+  ## Examples
+
+      iex> delete_user(user)
+      {:ok, %User{}}
+
+      iex> delete_user(user)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_user(%User{} = user) do
+    Repo.delete(user)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking user changes.
+
+  ## Examples
+
+      iex> change_user(user)
+      %Ecto.Changeset{source: %User{}}
+
+  """
+  def change_user(%User{} = user) do
+    User.changeset(user, %{})
+  end
+
+  alias Mobilizon.Actors.Member
+
+  @doc """
+  Gets a single member.
+
+  Raises `Ecto.NoResultsError` if the Member does not exist.
+
+  ## Examples
+
+      iex> get_member!(123)
+      %Member{}
+
+      iex> get_member!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_member!(id), do: Repo.get!(Member, id)
+
+  @doc """
+  Creates a member.
+
+  ## Examples
+
+      iex> create_member(%{field: value})
+      {:ok, %Member{}}
+
+      iex> create_member(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_member(attrs \\ %{}) do
+    with {:ok, %Member{} = member} <-
+           %Member{}
+           |> Member.changeset(attrs)
+           |> Repo.insert() do
+      {:ok, Repo.preload(member, [:actor, :parent])}
+    end
+  end
+
+  @doc """
+  Updates a member.
+
+  ## Examples
+
+      iex> update_member(member, %{field: new_value})
+      {:ok, %Member{}}
+
+      iex> update_member(member, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_member(%Member{} = member, attrs) do
+    member
+    |> Member.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a Member.
+
+  ## Examples
+
+      iex> delete_member(member)
+      {:ok, %Member{}}
+
+      iex> delete_member(member)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_member(%Member{} = member) do
+    Repo.delete(member)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking member changes.
+
+  ## Examples
+
+      iex> change_member(member)
+      %Ecto.Changeset{source: %Member{}}
+
+  """
+  def change_member(%Member{} = member) do
+    Member.changeset(member, %{})
+  end
+
+  def groups_for_actor(%Actor{id: id} = _actor) do
+    Repo.all(
+      from(
+        m in Member,
+        where: m.actor_id == ^id,
+        preload: [:parent]
+      )
+    )
+  end
+
+  def members_for_group(%Actor{type: :Group, id: id} = _group) do
+    Repo.all(
+      from(
+        m in Member,
+        where: m.parent_id == ^id,
+        preload: [:parent, :actor]
+      )
+    )
+  end
+
+  alias Mobilizon.Actors.Bot
+
+  @doc """
+  Returns the list of bots.
+
+  ## Examples
+
+      iex> list_bots()
+      [%Bot{}, ...]
+
+  """
+  def list_bots do
+    Repo.all(Bot)
+  end
+
+  @doc """
+  Gets a single bot.
+
+  Raises `Ecto.NoResultsError` if the Bot does not exist.
+
+  ## Examples
+
+      iex> get_bot!(123)
+      %Bot{}
+
+      iex> get_bot!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_bot!(id), do: Repo.get!(Bot, id)
+
+  @spec get_bot_by_actor(Actor.t()) :: Bot.t()
+  def get_bot_by_actor(%Actor{} = actor) do
+    Repo.get_by!(Bot, actor_id: actor.id)
+  end
+
+  @doc """
+  Creates a bot.
+
+  ## Examples
+
+      iex> create_bot(%{field: value})
+      {:ok, %Bot{}}
+
+      iex> create_bot(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_bot(attrs \\ %{}) do
+    %Bot{}
+    |> Bot.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a bot.
+
+  ## Examples
+
+      iex> update_bot(bot, %{field: new_value})
+      {:ok, %Bot{}}
+
+      iex> update_bot(bot, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_bot(%Bot{} = bot, attrs) do
+    bot
+    |> Bot.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a Bot.
+
+  ## Examples
+
+      iex> delete_bot(bot)
+      {:ok, %Bot{}}
+
+      iex> delete_bot(bot)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_bot(%Bot{} = bot) do
+    Repo.delete(bot)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking bot changes.
+
+  ## Examples
+
+      iex> change_bot(bot)
+      %Ecto.Changeset{source: %Bot{}}
+
+  """
+  def change_bot(%Bot{} = bot) do
+    Bot.changeset(bot, %{})
+  end
+
+  alias Mobilizon.Actors.Follower
+
+  @doc """
+  Gets a single follower.
+
+  Raises `Ecto.NoResultsError` if the Follower does not exist.
+
+  ## Examples
+
+      iex> get_follower!(123)
+      %Follower{}
+
+      iex> get_follower!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_follower!(id) do
+    Repo.get!(Follower, id)
+    |> Repo.preload([:actor, :target_actor])
+  end
+
+  @doc """
+  Creates a follower.
+
+  ## Examples
+
+      iex> create_follower(%{field: value})
+      {:ok, %Follower{}}
+
+      iex> create_follower(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_follower(attrs \\ %{}) do
+    %Follower{}
+    |> Follower.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a follower.
+
+  ## Examples
+
+      iex> update_follower(follower, %{field: new_value})
+      {:ok, %Follower{}}
+
+      iex> update_follower(follower, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_follower(%Follower{} = follower, attrs) do
+    follower
+    |> Follower.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a Follower.
+
+  ## Examples
+
+      iex> delete_follower(follower)
+      {:ok, %Follower{}}
+
+      iex> delete_follower(follower)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_follower(%Follower{} = follower) do
+    Repo.delete(follower)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking follower changes.
+
+  ## Examples
+
+      iex> change_follower(follower)
+      %Ecto.Changeset{source: %Follower{}}
+
+  """
+  def change_follower(%Follower{} = follower) do
+    Follower.changeset(follower, %{})
+  end
+end

lib/mobilizon/actors/bot.ex

@@ -0,0 +1,24 @@
+defmodule Mobilizon.Actors.Bot do
+  @moduledoc """
+  Represents a local bot
+  """
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Mobilizon.Actors.{Actor, User, Bot}
+
+  schema "bots" do
+    field(:source, :string)
+    field(:type, :string, default: :ics)
+    belongs_to(:actor, Actor)
+    belongs_to(:user, User)
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(bot, attrs) do
+    bot
+    |> cast(attrs, [:source, :type, :actor_id, :user_id])
+    |> validate_required([:source])
+  end
+end

lib/mobilizon/actors/follower.ex

@@ -0,0 +1,24 @@
+defmodule Mobilizon.Actors.Follower do
+  @moduledoc """
+  Represents the following of an actor to another actor
+  """
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Mobilizon.Actors.Follower
+  alias Mobilizon.Actors.Actor
+
+  schema "followers" do
+    field(:approved, :boolean, default: false)
+    field(:score, :integer, default: 1000)
+    belongs_to(:target_actor, Actor)
+    belongs_to(:actor, Actor)
+  end
+
+  @doc false
+  def changeset(%Follower{} = member, attrs) do
+    member
+    |> cast(attrs, [:score, :approved, :target_actor_id, :actor_id])
+    |> validate_required([:score, :approved, :target_actor_id, :actor_id])
+    |> unique_constraint(:target_actor_id, name: :followers_actor_target_actor_unique_index)
+  end
+end

lib/mobilizon/actors/member.ex

@@ -0,0 +1,27 @@
+defmodule Mobilizon.Actors.Member do
+  @moduledoc """
+  Represents the membership of an actor to a group
+  """
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Mobilizon.Actors.Member
+  alias Mobilizon.Actors.Actor
+
+  schema "members" do
+    field(:approved, :boolean, default: true)
+    # 0 : Member, 1 : Moderator, 2 : Admin
+    field(:role, :integer, default: 0)
+    belongs_to(:parent, Actor)
+    belongs_to(:actor, Actor)
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(%Member{} = member, attrs) do
+    member
+    |> cast(attrs, [:role, :approved, :parent_id, :actor_id])
+    |> validate_required([:parent_id, :actor_id])
+    |> unique_constraint(:parent_id, name: :members_actor_parent_unique_index)
+  end
+end

lib/mobilizon/actors/service/activation.ex

@@ -0,0 +1,35 @@
+defmodule Mobilizon.Actors.Service.Activation do
+  @moduledoc false
+
+  alias Mobilizon.{Mailer, Repo, Actors.User, Actors}
+  alias Mobilizon.Email.User, as: UserEmail
+
+  require Logger
+
+  @doc false
+  def check_confirmation_token(token) when is_binary(token) do
+    with %User{} = user <- Repo.get_by(User, confirmation_token: token),
+         {:ok, %User{} = user} <-
+           Actors.update_user(user, %{
+             "confirmed_at" => DateTime.utc_now(),
+             "confirmation_sent_at" => nil,
+             "confirmation_token" => nil
+           }) do
+      {:ok, Repo.preload(user, :actors)}
+    else
+      _err ->
+        {:error, "Invalid token"}
+    end
+  end
+
+  def resend_confirmation_email(%User{} = user, locale \\ "en") do
+    {:ok, user} = Actors.update_user(user, %{"confirmation_sent_at" => DateTime.utc_now()})
+    send_confirmation_email(user, locale)
+  end
+
+  def send_confirmation_email(%User{} = user, locale \\ "en") do
+    user
+    |> UserEmail.confirmation_email(locale)
+    |> Mailer.deliver_later()
+  end
+end

lib/mobilizon/actors/service/reset_password.ex

@@ -0,0 +1,77 @@
+defmodule Mobilizon.Actors.Service.ResetPassword do
+  @moduledoc false
+
+  require Logger
+
+  alias Mobilizon.{Mailer, Repo, Actors.User}
+  alias Mobilizon.Email.User, as: UserEmail
+
+  @doc """
+  Check that the provided token is correct and update provided password
+  """
+  @spec check_reset_password_token(String.t(), String.t()) :: tuple
+  def check_reset_password_token(password, token) do
+    with %User{} = user <- Repo.get_by(User, reset_password_token: token),
+         {:ok, %User{} = user} <-
+           Repo.update(
+             User.password_reset_changeset(user, %{
+               "password" => password,
+               "reset_password_sent_at" => nil,
+               "reset_password_token" => nil
+             })
+           ) do
+      {:ok, Repo.preload(user, :actors)}
+    else
+      err ->
+        {:error, :invalid_token}
+    end
+  end
+
+  @doc """
+  Send the email reset password, if it's not too soon since the last send
+  """
+  @spec send_password_reset_email(User.t(), String.t()) :: tuple
+  def send_password_reset_email(%User{} = user, locale \\ "en") do
+    with :ok <- we_can_send_email(user),
+         {:ok, %User{} = user_updated} <-
+           Repo.update(
+             User.send_password_reset_changeset(user, %{
+               "reset_password_token" => random_string(30),
+               "reset_password_sent_at" => DateTime.utc_now()
+             })
+           ) do
+      mail =
+        user_updated
+        |> UserEmail.reset_password_email(locale)
+        |> Mailer.deliver_later()
+
+      {:ok, mail}
+    else
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  @spec random_string(integer) :: String.t()
+  defp random_string(length) do
+    length
+    |> :crypto.strong_rand_bytes()
+    |> Base.url_encode64()
+  end
+
+  @spec we_can_send_email(User.t()) :: boolean
+  defp we_can_send_email(%User{} = user) do
+    case user.reset_password_sent_at do
+      nil ->
+        :ok
+
+      _ ->
+        case Timex.before?(Timex.shift(user.reset_password_sent_at, hours: 1), DateTime.utc_now()) do
+          true ->
+            :ok
+
+          false ->
+            {:error, :email_too_soon}
+        end
+    end
+  end
+end

lib/mobilizon/actors/user.ex

@@ -0,0 +1,125 @@
+defmodule Mobilizon.Actors.User do
+  @moduledoc """
+  Represents a local user
+  """
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Mobilizon.Actors.{Actor, User}
+
+  schema "users" do
+    field(:email, :string)
+    field(:password_hash, :string)
+    field(:password, :string, virtual: true)
+    field(:role, :integer, default: 0)
+    has_many(:actors, Actor)
+    field(:confirmed_at, :utc_datetime)
+    field(:confirmation_sent_at, :utc_datetime)
+    field(:confirmation_token, :string)
+    field(:reset_password_sent_at, :utc_datetime)
+    field(:reset_password_token, :string)
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(%User{} = user, attrs) do
+    user
+    |> cast(attrs, [
+      :email,
+      :role,
+      :password_hash,
+      :confirmed_at,
+      :confirmation_sent_at,
+      :confirmation_token,
+      :reset_password_sent_at,
+      :reset_password_token
+    ])
+    |> validate_required([:email])
+    |> unique_constraint(:email, message: "registration.error.email_already_used")
+    |> validate_format(:email, ~r/@/)
+    |> validate_length(
+      :password,
+      min: 6,
+      max: 100,
+      message: "registration.error.password_too_short"
+    )
+  end
+
+  def registration_changeset(struct, params) do
+    struct
+    |> changeset(params)
+    |> cast(params, ~w(password)a, [])
+    |> validate_required([:email, :password])
+    |> validate_length(
+      :password,
+      min: 6,
+      max: 100,
+      message: "registration.error.password_too_short"
+    )
+    |> hash_password()
+    |> save_confirmation_token()
+    |> unique_constraint(
+      :confirmation_token,
+      message: "regisration.error.confirmation_token_already_in_use"
+    )
+  end
+
+  def send_password_reset_changeset(%User{} = user, attrs) do
+    user
+    |> cast(attrs, [:reset_password_token, :reset_password_sent_at])
+  end
+
+  def password_reset_changeset(%User{} = user, attrs) do
+    user
+    |> cast(attrs, [:password, :reset_password_token, :reset_password_sent_at])
+    |> validate_length(
+      :password,
+      min: 6,
+      max: 100,
+      message: "registration.error.password_too_short"
+    )
+    |> hash_password()
+  end
+
+  defp save_confirmation_token(changeset) do
+    case changeset do
+      %Ecto.Changeset{valid?: true, changes: %{email: _email}} ->
+        changeset = put_change(changeset, :confirmation_token, random_string(30))
+        put_change(changeset, :confirmation_sent_at, DateTime.utc_now())
+
+      _ ->
+        changeset
+    end
+  end
+
+  defp random_string(length) do
+    length
+    |> :crypto.strong_rand_bytes()
+    |> Base.url_encode64()
+  end
+
+  @doc """
+  Hash password when it's changed
+  """
+  defp hash_password(changeset) do
+    case changeset do
+      %Ecto.Changeset{valid?: true, changes: %{password: password}} ->
+        put_change(
+          changeset,
+          :password_hash,
+          Comeonin.Argon2.hashpwsalt(password)
+        )
+
+      _ ->
+        changeset
+    end
+  end
+
+  def is_confirmed(%User{confirmed_at: nil} = _user) do
+    {:error, :unconfirmed}
+  end
+
+  def is_confirmed(%User{} = user) do
+    {:ok, user}
+  end
+end

lib/mobilizon/addresses/address.ex

@@ -0,0 +1,39 @@
+defmodule Mobilizon.Addresses.Address do
+  @moduledoc "An address for an event or a group"
+
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Mobilizon.Addresses.Address
+  alias Mobilizon.Events.Event
+  alias Mobilizon.Groups.Group
+
+  schema "addresses" do
+    field(:addressCountry, :string)
+    field(:addressLocality, :string)
+    field(:addressRegion, :string)
+    field(:description, :string)
+    field(:floor, :string)
+    field(:geom, Geo.PostGIS.Geometry)
+    field(:postalCode, :string)
+    field(:streetAddress, :string)
+    has_one(:event, Event)
+    has_one(:group, Group)
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(%Address{} = address, attrs) do
+    address
+    |> cast(attrs, [
+      :description,
+      :floor,
+      :geom,
+      :addressCountry,
+      :addressLocality,
+      :addressRegion,
+      :postalCode,
+      :streetAddress
+    ])
+  end
+end

lib/mobilizon/addresses/addresses.ex

@@ -0,0 +1,149 @@
+defmodule Mobilizon.Addresses do
+  @moduledoc """
+  The Addresses context.
+  """
+
+  import Ecto.Query, warn: false
+  alias Mobilizon.Repo
+
+  alias Mobilizon.Addresses.Address
+
+  import Logger
+
+  @geom_types [:point]
+
+  @doc """
+  Returns the list of addresses.
+
+  ## Examples
+
+      iex> list_addresses()
+      [%Address{}, ...]
+
+  """
+  def list_addresses do
+    Repo.all(Address)
+  end
+
+  @doc """
+  Gets a single address.
+
+  Raises `Ecto.NoResultsError` if the Address does not exist.
+
+  ## Examples
+
+      iex> get_address!(123)
+      %Address{}
+
+      iex> get_address!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_address!(id), do: Repo.get!(Address, id)
+
+  @doc """
+  Creates a address.
+
+  ## Examples
+
+      iex> create_address(%{field: value})
+      {:ok, %Address{}}
+
+      iex> create_address(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_address(attrs \\ %{}) do
+    %Address{}
+    |> Address.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a address.
+
+  ## Examples
+
+      iex> update_address(address, %{field: new_value})
+      {:ok, %Address{}}
+
+      iex> update_address(address, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_address(%Address{} = address, attrs) do
+    address
+    |> Address.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a Address.
+
+  ## Examples
+
+      iex> delete_address(address)
+      {:ok, %Address{}}
+
+      iex> delete_address(address)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_address(%Address{} = address) do
+    Repo.delete(address)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking address changes.
+
+  ## Examples
+
+      iex> change_address(address)
+      %Ecto.Changeset{source: %Address{}}
+
+  """
+  def change_address(%Address{} = address) do
+    Address.changeset(address, %{})
+  end
+
+  @doc """
+  Processes raw geo data informations and return a `Geo` geometry which can be one of `Geo.Point`.
+  """
+  def process_geom(%{"type" => type_input, "data" => data}) do
+    type =
+      if !is_atom(type_input) && type_input != nil do
+        try do
+          String.to_existing_atom(type_input)
+        rescue
+          e in ArgumentError ->
+            Logger.error("#{type_input} is not an existing atom : #{inspect(e)}")
+            nil
+        end
+      else
+        type_input
+      end
+
+    if Enum.member?(@geom_types, type) do
+      case type do
+        :point ->
+          process_point(data["latitude"], data["longitude"])
+      end
+    else
+      {:error, nil}
+    end
+  end
+
+  @doc false
+  def process_geom(nil) do
+    {:error, nil}
+  end
+
+  @spec process_point(number(), number()) :: tuple()
+  defp process_point(latitude, longitude) when is_number(latitude) and is_number(longitude) do
+    {:ok, %Geo.Point{coordinates: {latitude, longitude}, srid: 4326}}
+  end
+
+  defp process_point(_, _) do
+    {:error, "Latitude and longitude must be numbers"}
+  end
+end

lib/mobilizon/application.ex

@@ -0,0 +1,36 @@
+defmodule Mobilizon.Application do
+  @moduledoc """
+  The Mobilizon application
+  """
+  use Application
+
+  # See https://hexdocs.pm/elixir/Application.html
+  # for more information on OTP Applications
+  def start(_type, _args) do
+    import Supervisor.Spec
+
+    # Define workers and child supervisors to be supervised
+    children = [
+      # Start the Ecto repository
+      supervisor(Mobilizon.Repo, []),
+      # Start the endpoint when the application starts
+      supervisor(MobilizonWeb.Endpoint, []),
+      # Start your own worker by calling: Mobilizon.Worker.start_link(arg1, arg2, arg3)
+      # worker(Mobilizon.Worker, [arg1, arg2, arg3]),
+      worker(Guardian.DB.Token.SweeperServer, []),
+      worker(Mobilizon.Service.Federator, [])
+    ]
+
+    # See https://hexdocs.pm/elixir/Supervisor.html
+    # for other strategies and supported options
+    opts = [strategy: :one_for_one, name: Mobilizon.Supervisor]
+    Supervisor.start_link(children, opts)
+  end
+
+  # Tell Phoenix to update the endpoint configuration
+  # whenever the application is updated.
+  def config_change(changed, _new, removed) do
+    MobilizonWeb.Endpoint.config_change(changed, removed)
+    :ok
+  end
+end

lib/mobilizon/email/user.ex

@@ -0,0 +1,57 @@
+defmodule Mobilizon.Email.User do
+  @moduledoc """
+  Handles emails sent to users
+  """
+  alias Mobilizon.Actors.User
+
+  import Bamboo.Email
+  import Bamboo.Phoenix
+  use Bamboo.Phoenix, view: Mobilizon.EmailView
+  import MobilizonWeb.Gettext
+
+  def confirmation_email(%User{} = user, locale \\ "en") do
+    Gettext.put_locale(locale)
+    instance_url = get_config(:instance)
+
+    base_email()
+    |> to(user.email)
+    |> subject(
+      gettext("Peakweaver: Confirmation instructions for %{instance}", instance: instance_url)
+    )
+    |> put_header("Reply-To", get_config(:reply_to))
+    |> assign(:token, user.confirmation_token)
+    |> assign(:instance, instance_url)
+    |> render(:registration_confirmation)
+  end
+
+  def reset_password_email(%User{} = user, locale \\ "en") do
+    Gettext.put_locale(locale)
+    instance_url = get_config(:instance)
+
+    base_email()
+    |> to(user.email)
+    |> subject(
+      gettext(
+        "Peakweaver: Reset your password on %{instance} instructions",
+        instance: instance_url
+      )
+    )
+    |> put_header("Reply-To", get_config(:reply_to))
+    |> assign(:token, user.reset_password_token)
+    |> assign(:instance, instance_url)
+    |> render(:password_reset)
+  end
+
+  defp base_email do
+    # Here you can set a default from, default headers, etc.
+    new_email()
+    |> from(Application.get_env(:mobilizon, MobilizonWeb.Endpoint)[:email_from])
+    |> put_html_layout({Mobilizon.EmailView, "email.html"})
+    |> put_text_layout({Mobilizon.EmailView, "email.text"})
+  end
+
+  @spec get_config(atom()) :: any()
+  defp get_config(key) do
+    _config = Application.get_env(:mobilizon, MobilizonWeb.Endpoint) |> Keyword.get(key)
+  end
+end

lib/mobilizon/events/category.ex

@@ -0,0 +1,24 @@
+defmodule Mobilizon.Events.Category do
+  @moduledoc """
+  Represents a category for events
+  """
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Mobilizon.Events.Category
+
+  schema "categories" do
+    field(:description, :string)
+    field(:picture, :string)
+    field(:title, :string, null: false)
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(%Category{} = category, attrs) do
+    category
+    |> cast(attrs, [:title, :description, :picture])
+    |> validate_required([:title])
+    |> unique_constraint(:title)
+  end
+end

lib/mobilizon/events/comment.ex

@@ -0,0 +1,43 @@
+defmodule Mobilizon.Events.Comment do
+  @moduledoc """
+  An actor comment (for instance on an event or on a group)
+  """
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  alias Mobilizon.Events.Event
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Actors.Comment
+
+  schema "comments" do
+    field(:text, :string)
+    field(:url, :string)
+    field(:local, :boolean, default: true)
+    field(:uuid, Ecto.UUID)
+    belongs_to(:actor, Actor, foreign_key: :actor_id)
+    belongs_to(:attributed_to, Actor, foreign_key: :attributed_to_id)
+    belongs_to(:event, Event, foreign_key: :event_id)
+    belongs_to(:in_reply_to_comment, Comment, foreign_key: :in_reply_to_comment_id)
+    belongs_to(:origin_comment, Comment, foreign_key: :origin_comment_id)
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc false
+  def changeset(comment, attrs) do
+    uuid = Ecto.UUID.generate()
+
+    # TODO : really change me right away
+    url =
+      if Map.has_key?(attrs, "url"),
+        do: attrs["url"],
+        else: "#{MobilizonWeb.Endpoint.url()}/comments/#{uuid}"
+
+    comment
+    |> cast(attrs, [:url, :text, :actor_id, :event_id, :in_reply_to_comment_id, :attributed_to_id])
+    |> put_change(:uuid, uuid)
+    |> put_change(:url, url)
+    |> validate_required([:text, :actor_id, :url])
+  end
+end

lib/mobilizon/events/event.ex

@@ -0,0 +1,97 @@
+import EctoEnum
+defenum(AddressTypeEnum, :address_type, [:physical, :url, :phone, :other])
+
+defmodule Mobilizon.Events.Event do
+  @moduledoc """
+  Represents an event
+  """
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Mobilizon.Events.{Event, Participant, Tag, Category, Session, Track}
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Addresses.Address
+
+  schema "events" do
+    field(:url, :string)
+    field(:local, :boolean, default: true)
+    field(:begins_on, Timex.Ecto.DateTimeWithTimezone)
+    field(:description, :string)
+    field(:ends_on, Timex.Ecto.DateTimeWithTimezone)
+    field(:title, :string)
+    # ???
+    field(:state, :integer, default: 0)
+    # Event status: TENTATIVE 1, CONFIRMED 2, CANCELLED 3
+    field(:status, :integer, default: 0)
+    # If the event is public or private
+    field(:public, :boolean, default: true)
+    field(:thumbnail, :string)
+    field(:large_image, :string)
+    field(:publish_at, Timex.Ecto.DateTimeWithTimezone)
+    field(:uuid, Ecto.UUID, default: Ecto.UUID.generate())
+    field(:address_type, AddressTypeEnum, default: :physical)
+    field(:online_address, :string)
+    field(:phone, :string)
+    belongs_to(:organizer_actor, Actor, foreign_key: :organizer_actor_id)
+    belongs_to(:attributed_to, Actor, foreign_key: :attributed_to_id)
+    many_to_many(:tags, Tag, join_through: "events_tags")
+    belongs_to(:category, Category)
+    many_to_many(:participants, Actor, join_through: Participant)
+    has_many(:tracks, Track)
+    has_many(:sessions, Session)
+    belongs_to(:physical_address, Address)
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc false
+  def changeset(%Event{} = event, attrs) do
+    # TODO : Change all of this
+    actor_url =
+      if Map.has_key?(attrs, :organizer_actor) do
+        attrs.organizer_actor.preferred_username
+      else
+        ""
+      end
+
+    uuid = Ecto.UUID.generate()
+
+    url =
+      if Map.has_key?(attrs, "url"),
+        do: attrs["url"],
+        else: "#{MobilizonWeb.Endpoint.url()}/@#{actor_url}/#{uuid}"
+
+    event
+    |> Ecto.Changeset.cast(attrs, [
+      :title,
+      :description,
+      :url,
+      :begins_on,
+      :ends_on,
+      :organizer_actor_id,
+      :category_id,
+      :state,
+      :status,
+      :public,
+      :thumbnail,
+      :large_image,
+      :publish_at,
+      :address_type,
+      :online_address,
+      :phone
+    ])
+    |> cast_assoc(:tags)
+    |> cast_assoc(:physical_address)
+    |> put_change(:uuid, uuid)
+    |> put_change(:url, url)
+    |> validate_required([
+      :title,
+      :begins_on,
+      :ends_on,
+      :organizer_actor_id,
+      :category_id,
+      :url,
+      :uuid,
+      :address_type
+    ])
+  end
+end

lib/mobilizon/events/events.ex

@@ -0,0 +1,911 @@
+defmodule Mobilizon.Events do
+  @moduledoc """
+  The Events context.
+  """
+
+  import Ecto.Query, warn: false
+  alias Mobilizon.Repo
+
+  alias Mobilizon.Events.Event
+  alias Mobilizon.Events.Comment
+  alias Mobilizon.Actors.Actor
+  alias Mobilizon.Addresses.Address
+
+  @doc """
+  Returns the list of events.
+
+  ## Examples
+
+      iex> list_events()
+      [%Event{}, ...]
+
+  """
+  def list_events do
+    events = Repo.all(Event)
+    Repo.preload(events, [:organizer_actor])
+  end
+
+  def get_events_for_actor(%Actor{id: actor_id} = _actor, page \\ 1, limit \\ 10) do
+    start = (page - 1) * limit
+
+    query =
+      from(
+        e in Event,
+        where: e.organizer_actor_id == ^actor_id,
+        limit: ^limit,
+        order_by: [desc: :id],
+        offset: ^start,
+        preload: [
+          :organizer_actor,
+          :category,
+          :sessions,
+          :tracks,
+          :tags,
+          :participants,
+          :physical_address
+        ]
+      )
+
+    events = Repo.all(query)
+
+    count_events =
+      Repo.one(from(e in Event, select: count(e.id), where: e.organizer_actor_id == ^actor_id))
+
+    {:ok, events, count_events}
+  end
+
+  def count_local_events do
+    Repo.one(
+      from(
+        e in Event,
+        select: count(e.id),
+        where: e.local == ^true
+      )
+    )
+  end
+
+  def count_local_comments do
+    Repo.one(
+      from(
+        c in Comment,
+        select: count(c.id),
+        where: c.local == ^true
+      )
+    )
+  end
+
+  import Geo.PostGIS
+
+  # 50 000 meters -> 50 kms
+  def find_close_events(lon, lat, radius \\ 50_000) do
+    with {:ok, ip_point} <- Geo.WKT.decode("SRID=4326;POINT(#{lon} #{lat})") do
+      Repo.all(
+        from(
+          e in Event,
+          join: a in Address,
+          on: a.id == e.physical_address_id,
+          where: st_dwithin_in_meters(^ip_point, a.geom, ^radius),
+          preload: :organizer_actor
+        )
+      )
+    end
+  end
+
+  @doc """
+  Gets a single event.
+
+  Raises `Ecto.NoResultsError` if the Event does not exist.
+
+  ## Examples
+
+      iex> get_event!(123)
+      %Event{}
+
+      iex> get_event!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_event!(id), do: Repo.get!(Event, id)
+
+  @doc """
+  Gets an event by it's URL
+  """
+  def get_event_by_url(url) do
+    Repo.get_by(Event, url: url)
+  end
+
+  @doc """
+  Gets an event by it's URL
+  """
+  def get_event_by_url!(url) do
+    Repo.get_by!(Event, url: url)
+  end
+
+  @doc """
+  Gets an event by it's UUID
+  """
+  def get_event_by_uuid(uuid) do
+    Repo.get_by(Event, uuid: uuid)
+  end
+
+  @doc """
+  Gets a single event, with all associations loaded.
+  """
+  def get_event_full!(id) do
+    event = Repo.get!(Event, id)
+
+    Repo.preload(event, [
+      :organizer_actor,
+      :category,
+      :sessions,
+      :tracks,
+      :tags,
+      :participants,
+      :physical_address
+    ])
+  end
+
+  @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
+    ])
+  end
+
+  @doc """
+  Gets a full event by it's UUID
+  """
+  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 """
+  Find events by name
+  """
+  def find_events_by_name(name) when name == "", do: []
+
+  def find_events_by_name(name) do
+    name = String.trim(name)
+    events = Repo.all(from(a in Event, where: ilike(a.title, ^like_sanitize(name))))
+    Repo.preload(events, [:organizer_actor])
+  end
+
+  @doc """
+  Sanitize the LIKE queries
+  """
+  defp like_sanitize(value) do
+    "%" <> String.replace(value, ~r/([\\%_])/, "\\1") <> "%"
+  end
+
+  @doc """
+  Creates a event.
+
+  ## Examples
+
+      iex> create_event(%{field: value})
+      {:ok, %Event{}}
+
+      iex> create_event(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_event(attrs \\ %{}) do
+    case %Event{} |> Event.changeset(attrs) |> Repo.insert() do
+      {:ok, %Event{} = event} -> {:ok, Repo.preload(event, [:organizer_actor])}
+      err -> err
+    end
+  end
+
+  @doc """
+  Updates a event.
+
+  ## Examples
+
+      iex> update_event(event, %{field: new_value})
+      {:ok, %Event{}}
+
+      iex> update_event(event, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_event(%Event{} = event, attrs) do
+    event
+    |> Event.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a Event.
+
+  ## Examples
+
+      iex> delete_event(event)
+      {:ok, %Event{}}
+
+      iex> delete_event(event)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_event(%Event{} = event) do
+    Repo.delete(event)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking event changes.
+
+  ## Examples
+
+      iex> change_event(event)
+      %Ecto.Changeset{source: %Event{}}
+
+  """
+  def change_event(%Event{} = event) do
+    Event.changeset(event, %{})
+  end
+
+  alias Mobilizon.Events.Category
+
+  @doc """
+  Returns the list of categories.
+
+  ## Examples
+
+      iex> list_categories()
+      [%Category{}, ...]
+
+  """
+  def list_categories do
+    Repo.all(Category)
+  end
+
+  @doc """
+  Gets a single category.
+
+  Raises `Ecto.NoResultsError` if the Category does not exist.
+
+  ## Examples
+
+      iex> get_category!(123)
+      %Category{}
+
+      iex> get_category!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_category!(id), do: Repo.get!(Category, id)
+
+  @spec get_category_by_title(String.t()) :: tuple()
+  def get_category_by_title(title) when is_binary(title) do
+    Repo.get_by(Category, title: title)
+  end
+
+  @doc """
+  Creates a category.
+
+  ## Examples
+
+      iex> create_category(%{field: value})
+      {:ok, %Category{}}
+
+      iex> create_category(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_category(attrs \\ %{}) do
+    %Category{}
+    |> Category.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a category.
+
+  ## Examples
+
+      iex> update_category(category, %{field: new_value})
+      {:ok, %Category{}}
+
+      iex> update_category(category, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_category(%Category{} = category, attrs) do
+    category
+    |> Category.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a Category.
+
+  ## Examples
+
+      iex> delete_category(category)
+      {:ok, %Category{}}
+
+      iex> delete_category(category)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_category(%Category{} = category) do
+    Repo.delete(category)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking category changes.
+
+  ## Examples
+
+      iex> change_category(category)
+      %Ecto.Changeset{source: %Category{}}
+
+  """
+  def change_category(%Category{} = category) do
+    Category.changeset(category, %{})
+  end
+
+  alias Mobilizon.Events.Tag
+
+  @doc """
+  Returns the list of tags.
+
+  ## Examples
+
+      iex> list_tags()
+      [%Tag{}, ...]
+
+  """
+  def list_tags do
+    Repo.all(Tag)
+  end
+
+  @doc """
+  Gets a single tag.
+
+  Raises `Ecto.NoResultsError` if the Tag does not exist.
+
+  ## Examples
+
+      iex> get_tag!(123)
+      %Tag{}
+
+      iex> get_tag!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_tag!(id), do: Repo.get!(Tag, id)
+
+  @doc """
+  Creates a tag.
+
+  ## Examples
+
+      iex> create_tag(%{field: value})
+      {:ok, %Tag{}}
+
+      iex> create_tag(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_tag(attrs \\ %{}) do
+    %Tag{}
+    |> Tag.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a tag.
+
+  ## Examples
+
+      iex> update_tag(tag, %{field: new_value})
+      {:ok, %Tag{}}
+
+      iex> update_tag(tag, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_tag(%Tag{} = tag, attrs) do
+    tag
+    |> Tag.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a Tag.
+
+  ## Examples
+
+      iex> delete_tag(tag)
+      {:ok, %Tag{}}
+
+      iex> delete_tag(tag)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_tag(%Tag{} = tag) do
+    Repo.delete(tag)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking tag changes.
+
+  ## Examples
+
+      iex> change_tag(tag)
+      %Ecto.Changeset{source: %Tag{}}
+
+  """
+  def change_tag(%Tag{} = tag) do
+    Tag.changeset(tag, %{})
+  end
+
+  alias Mobilizon.Events.Participant
+
+  @doc """
+  Returns the list of participants.
+
+  ## Examples
+
+      iex> list_participants()
+      [%Participant{}, ...]
+
+  """
+  def list_participants do
+    Repo.all(Participant)
+  end
+
+  @doc """
+  Gets a single participant.
+
+  Raises `Ecto.NoResultsError` if the Participant does not exist.
+
+  ## Examples
+
+      iex> get_participant!(123)
+      %Participant{}
+
+      iex> get_participant!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_participant!(event_id, actor_id) do
+    Repo.get_by!(Participant, event_id: event_id, actor_id: actor_id)
+  end
+
+  @doc """
+  Creates a participant.
+
+  ## Examples
+
+      iex> create_participant(%{field: value})
+      {:ok, %Participant{}}
+
+      iex> create_participant(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_participant(attrs \\ %{}) do
+    %Participant{}
+    |> Participant.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a participant.
+
+  ## Examples
+
+      iex> update_participant(participant, %{field: new_value})
+      {:ok, %Participant{}}
+
+      iex> update_participant(participant, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_participant(%Participant{} = participant, attrs) do
+    participant
+    |> Participant.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a Participant.
+
+  ## Examples
+
+      iex> delete_participant(participant)
+      {:ok, %Participant{}}
+
+      iex> delete_participant(participant)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_participant(%Participant{} = participant) do
+    Repo.delete(participant)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking participant changes.
+
+  ## Examples
+
+      iex> change_participant(participant)
+      %Ecto.Changeset{source: %Participant{}}
+
+  """
+  def change_participant(%Participant{} = participant) 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))
+  end
+
+  alias Mobilizon.Events.Session
+
+  @doc """
+  Returns the list of sessions.
+
+  ## Examples
+
+      iex> list_sessions()
+      [%Session{}, ...]
+
+  """
+  def list_sessions do
+    Repo.all(Session)
+  end
+
+  @doc """
+  Returns the list of sessions for an event
+  """
+  def list_sessions_for_event(event_uuid) do
+    Repo.all(
+      from(
+        s in Session,
+        join: e in Event,
+        on: s.event_id == e.id,
+        where: e.uuid == ^event_uuid
+      )
+    )
+  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.
+
+  Raises `Ecto.NoResultsError` if the Session does not exist.
+
+  ## Examples
+
+      iex> get_session!(123)
+      %Session{}
+
+      iex> get_session!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_session!(id), do: Repo.get!(Session, id)
+
+  @doc """
+  Creates a session.
+
+  ## Examples
+
+      iex> create_session(%{field: value})
+      {:ok, %Session{}}
+
+      iex> create_session(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_session(attrs \\ %{}) do
+    %Session{}
+    |> Session.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a session.
+
+  ## Examples
+
+      iex> update_session(session, %{field: new_value})
+      {:ok, %Session{}}
+
+      iex> update_session(session, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_session(%Session{} = session, attrs) do
+    session
+    |> Session.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a Session.
+
+  ## Examples
+
+      iex> delete_session(session)
+      {:ok, %Session{}}
+
+      iex> delete_session(session)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_session(%Session{} = session) do
+    Repo.delete(session)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking session changes.
+
+  ## Examples
+
+      iex> change_session(session)
+      %Ecto.Changeset{source: %Session{}}
+
+  """
+  def change_session(%Session{} = session) do
+    Session.changeset(session, %{})
+  end
+
+  alias Mobilizon.Events.Track
+
+  @doc """
+  Returns the list of tracks.
+
+  ## Examples
+
+      iex> list_tracks()
+      [%Track{}, ...]
+
+  """
+  def list_tracks do
+    Repo.all(Track)
+  end
+
+  @doc """
+  Gets a single track.
+
+  Raises `Ecto.NoResultsError` if the Track does not exist.
+
+  ## Examples
+
+      iex> get_track!(123)
+      %Track{}
+
+      iex> get_track!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_track!(id), do: Repo.get!(Track, id)
+
+  @doc """
+  Creates a track.
+
+  ## Examples
+
+      iex> create_track(%{field: value})
+      {:ok, %Track{}}
+
+      iex> create_track(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_track(attrs \\ %{}) do
+    %Track{}
+    |> Track.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a track.
+
+  ## Examples
+
+      iex> update_track(track, %{field: new_value})
+      {:ok, %Track{}}
+
+      iex> update_track(track, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_track(%Track{} = track, attrs) do
+    track
+    |> Track.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a Track.
+
+  ## Examples
+
+      iex> delete_track(track)
+      {:ok, %Track{}}
+
+      iex> delete_track(track)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_track(%Track{} = track) do
+    Repo.delete(track)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking track changes.
+
+  ## Examples
+
+      iex> change_track(track)
+      %Ecto.Changeset{source: %Track{}}
+
+  """
+  def change_track(%Track{} = track) do
+    Track.changeset(track, %{})
+  end
+
+  alias Mobilizon.Events.Comment
+
+  @doc """
+  Returns the list of comments.
+
+  ## Examples
+
+      iex> list_comments()
+      [%Comment{}, ...]
+
+  """
+  def list_comments do
+    Repo.all(Comment)
+  end
+
+  def get_comments_for_actor(%Actor{id: actor_id}, page \\ 1, limit \\ 10) do
+    start = (page - 1) * limit
+
+    query =
+      from(
+        c in Comment,
+        where: c.actor_id == ^actor_id,
+        limit: ^limit,
+        order_by: [desc: :id],
+        offset: ^start,
+        preload: [
+          :actor,
+          :in_reply_to_comment,
+          :origin_comment,
+          :event
+        ]
+      )
+
+    comments = Repo.all(query)
+
+    count_comments =
+      Repo.one(from(c in Comment, select: count(c.id), where: c.actor_id == ^actor_id))
+
+    {:ok, comments, count_comments}
+  end
+
+  @doc """
+  Gets a single comment.
+
+  Raises `Ecto.NoResultsError` if the Comment does not exist.
+
+  ## Examples
+
+      iex> get_comment!(123)
+      %Comment{}
+
+      iex> get_comment!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_comment!(id), do: Repo.get!(Comment, id)
+
+  def get_comment_with_uuid!(uuid), do: Repo.get_by!(Comment, uuid: uuid)
+
+  def get_comment_from_url(url), do: Repo.get_by(Comment, url: url)
+
+  def get_comment_from_url!(url), do: Repo.get_by!(Comment, url: url)
+
+  def get_comment_full_from_url!(url) do
+    with %Comment{} = comment <- Repo.get_by!(Comment, url: url) do
+      Repo.preload(comment, :actor)
+    end
+  end
+
+  @doc """
+  Creates a comment.
+
+  ## Examples
+
+      iex> create_comment(%{field: value})
+      {:ok, %Comment{}}
+
+      iex> create_comment(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_comment(attrs \\ %{}) do
+    %Comment{}
+    |> Comment.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a comment.
+
+  ## Examples
+
+      iex> update_comment(comment, %{field: new_value})
+      {:ok, %Comment{}}
+
+      iex> update_comment(comment, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_comment(%Comment{} = comment, attrs) do
+    comment
+    |> Comment.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a Comment.
+
+  ## Examples
+
+      iex> delete_comment(comment)
+      {:ok, %Comment{}}
+
+      iex> delete_comment(comment)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_comment(%Comment{} = comment) do
+    Repo.delete(comment)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking comment changes.
+
+  ## Examples
+
+      iex> change_comment(comment)
+      %Ecto.Changeset{source: %Comment{}}
+
+  """
+  def change_comment(%Comment{} = comment) do
+    Comment.changeset(comment, %{})
+  end
+end

lib/mobilizon/events/participant.ex

@@ -0,0 +1,26 @@
+defmodule Mobilizon.Events.Participant do
+  @moduledoc """
+  Represents a participant, an actor participating to an event
+  """
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Mobilizon.Events.{Participant, Event}
+  alias Mobilizon.Actors.Actor
+
+  @primary_key false
+  schema "participants" do
+    # 0 : not_approved, 1 : participant, 2 : moderator, 3 : administrator, 4 : creator
+    field(:role, :integer, default: 0)
+    belongs_to(:event, Event, primary_key: true)
+    belongs_to(:actor, Actor, primary_key: true)
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(%Participant{} = participant, attrs) do
+    participant
+    |> cast(attrs, [:role, :event_id, :actor_id])
+    |> validate_required([:role, :event_id, :actor_id])
+  end
+end

lib/mobilizon/events/session.ex

@@ -0,0 +1,52 @@
+defmodule Mobilizon.Events.Session do
+  @moduledoc """
+  Represents a session for an event (such as a talk at a conference)
+  """
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Mobilizon.Events.{Session, Event, Track}
+
+  schema "sessions" do
+    field(:audios_urls, :string)
+    field(:language, :string)
+    field(:long_abstract, :string)
+    field(:short_abstract, :string)
+    field(:slides_url, :string)
+    field(:subtitle, :string)
+    field(:title, :string)
+    field(:videos_urls, :string)
+    field(:begins_on, Timex.Ecto.DateTimeWithTimezone)
+    field(:ends_on, Timex.Ecto.DateTimeWithTimezone)
+    belongs_to(:event, Event)
+    belongs_to(:track, Track)
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(%Session{} = session, attrs) do
+    session
+    |> cast(attrs, [
+      :title,
+      :subtitle,
+      :short_abstract,
+      :long_abstract,
+      :language,
+      :slides_url,
+      :videos_urls,
+      :audios_urls,
+      :event_id,
+      :track_id
+    ])
+    |> validate_required([
+      :title,
+      :subtitle,
+      :short_abstract,
+      :long_abstract,
+      :language,
+      :slides_url,
+      :videos_urls,
+      :audios_urls
+    ])
+  end
+end

lib/mobilizon/events/tag.ex

@@ -0,0 +1,58 @@
+defmodule Mobilizon.Events.Tag.TitleSlug do
+  @moduledoc """
+  Generates slugs for tags
+  """
+  alias Mobilizon.Events.Tag
+  import Ecto.Query
+  alias Mobilizon.Repo
+  use EctoAutoslugField.Slug, from: :title, to: :slug
+
+  def build_slug(sources, changeset) do
+    slug = super(sources, changeset)
+    build_unique_slug(slug, changeset)
+  end
+
+  defp build_unique_slug(slug, changeset) do
+    query =
+      from(
+        t in Tag,
+        where: t.slug == ^slug
+      )
+
+    case Repo.one(query) do
+      nil ->
+        slug
+
+      _story ->
+        slug
+        |> Mobilizon.Slug.increment_slug()
+        |> build_unique_slug(changeset)
+    end
+  end
+end
+
+defmodule Mobilizon.Events.Tag do
+  @moduledoc """
+  Represents a tag for events
+  """
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Mobilizon.Events.Tag
+  alias Mobilizon.Events.Tag.TitleSlug
+
+  schema "tags" do
+    field(:title, :string)
+    field(:slug, TitleSlug.Type)
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(%Tag{} = tag, attrs) do
+    tag
+    |> cast(attrs, [:title])
+    |> validate_required([:title])
+    |> TitleSlug.maybe_generate_slug()
+    |> TitleSlug.unique_constraint()
+  end
+end

lib/mobilizon/events/track.ex

@@ -0,0 +1,25 @@
+defmodule Mobilizon.Events.Track do
+  @moduledoc """
+  Represents a track for an event (such as a theme) having multiple sessions
+  """
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Mobilizon.Events.{Track, Event, Session}
+
+  schema "tracks" do
+    field(:color, :string)
+    field(:description, :string)
+    field(:name, :string)
+    belongs_to(:event, Event)
+    has_many(:sessions, Session)
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(%Track{} = track, attrs) do
+    track
+    |> cast(attrs, [:name, :description, :color, :event_id])
+    |> validate_required([:name, :description, :color])
+  end
+end

lib/mobilizon/export/icalendar.ex

@@ -0,0 +1,23 @@
+defmodule Mobilizon.Export.ICalendar do
+  @moduledoc """
+  Export an event to iCalendar format
+  """
+
+  alias Mobilizon.Events.Event
+
+  @spec export_event(%Event{}) :: String
+  def export_event(%Event{} = event) do
+    events = [
+      %ICalendar.Event{
+        summary: event.title,
+        dtstart: event.begins_on,
+        dtend: event.ends_on,
+        description: event.description,
+        uid: event.uuid
+      }
+    ]
+
+    %ICalendar{events: events}
+    |> ICalendar.to_ics()
+  end
+end

lib/mobilizon/mailer.ex

@@ -0,0 +1,6 @@
+defmodule Mobilizon.Mailer do
+  @moduledoc """
+  Mailer
+  """
+  use Bamboo.Mailer, otp_app: :mobilizon
+end

lib/mobilizon/postgrex_types.ex

@@ -0,0 +1,5 @@
+Postgrex.Types.define(
+  Mobilizon.PostgresTypes,
+  [Geo.PostGIS.Extension] ++ Ecto.Adapters.Postgres.extensions(),
+  json: Poison
+)

lib/mobilizon/repo.ex

@@ -0,0 +1,14 @@
+defmodule Mobilizon.Repo do
+  @moduledoc """
+  Mobilizon Repo
+  """
+  use Ecto.Repo, otp_app: :mobilizon
+
+  @doc """
+  Dynamically loads the repository url from the
+  DATABASE_URL environment variable.
+  """
+  def init(_, opts) do
+    {:ok, Keyword.put(opts, :url, System.get_env("DATABASE_URL"))}
+  end
+end

lib/mobilizon/slug.ex

@@ -0,0 +1,17 @@
+defmodule Mobilizon.Slug do
+  @moduledoc """
+  Common functions for slug generation
+  """
+  def increment_slug(slug) do
+    case List.pop_at(String.split(slug, "-"), -1) do
+      {nil, _} ->
+        slug
+
+      {suffix, slug_parts} ->
+        case Integer.parse(suffix) do
+          {id, _} -> Enum.join(slug_parts, "-") <> "-" <> Integer.to_string(id + 1)
+          :error -> slug <> "-1"
+        end
+    end
+  end
+end