Change models, new migrations, fix front and make tests work

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

lib/eventos/events/category.ex

@@ -5,8 +5,9 @@ defmodule Eventos.Events.Category do
 
 
   schema "categories" do
+    field :description, :string
     field :picture, :string
-    field :title, :string
+    field :title, :string, null: false
 
     timestamps()
   end
@@ -14,8 +15,8 @@ defmodule Eventos.Events.Category do
   @doc false
   def changeset(%Category{} = category, attrs) do
     category
-    |> cast(attrs, [:title, :picture])
-    |> validate_required([:title, :picture])
+    |> cast(attrs, [:title, :description, :picture])
+    |> validate_required([:title])
     |> unique_constraint(:title)
   end
 end

lib/eventos/events/event.ex

@@ -1,18 +1,65 @@
+defmodule Eventos.Events.Event.TitleSlug do
+  alias Eventos.Events.Event
+  import Ecto.Query
+  alias Eventos.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 e in Event,
+                 where: e.slug == ^slug
+
+    case Repo.one(query) do
+      nil -> slug
+      _event ->
+        slug
+        |> increment_slug
+        |> build_unique_slug(changeset)
+    end
+  end
+
+  defp 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
+
 defmodule Eventos.Events.Event do
   use Ecto.Schema
   import Ecto.Changeset
-  alias Eventos.Events.{Event, EventAccount, EventRequest}
+  alias Eventos.Events.{Event, Participant, Request, Tag, Session, Track}
+  alias Eventos.Events.Event.TitleSlug
   alias Eventos.Accounts.Account
 
-
   schema "events" do
-    field :begin_on, :utc_datetime
+    field :begins_on, Timex.Ecto.DateTimeWithTimezone
     field :description, :string
-    field :ends_on, :utc_datetime
+    field :ends_on, Timex.Ecto.DateTimeWithTimezone
     field :title, :string
-    has_one :organizer_id, Account
-    many_to_many :participants, Account, join_through: EventAccount
-    has_many :event_request, EventRequest
+    field :geom, Geo.Geometry
+    field :slug, TitleSlug.Type
+    field :state, :integer, default: 0
+    field :public, :boolean, default: true
+    field :thumbnail, :string
+    field :large_image, :string
+    field :publish_at, Timex.Ecto.DateTimeWithTimezone
+    belongs_to :organizer, Account, [foreign_key: :organizer_id]
+    has_many :tags, Tag
+    many_to_many :participants, Account, join_through: Participant
+    has_many :event_request, Request
+    has_many :tracks, Track
+    has_many :sessions, Session
 
     timestamps()
   end
@@ -20,7 +67,9 @@ defmodule Eventos.Events.Event do
   @doc false
   def changeset(%Event{} = event, attrs) do
     event
-    |> cast(attrs, [:title, :description, :begin_on, :ends_on])
-    |> validate_required([:title, :description, :begin_on, :ends_on, :organizer_id])
+    |> cast(attrs, [:title, :description, :begins_on, :ends_on, :organizer_id])
+    |> validate_required([:title, :description, :begins_on, :ends_on, :organizer_id])
+    |> TitleSlug.maybe_generate_slug()
+    |> TitleSlug.unique_constraint()
   end
-end
+end

lib/eventos/events/event_accounts.ex

@@ -1,22 +0,0 @@
-defmodule Eventos.Events.EventAccounts do
-  use Ecto.Schema
-  import Ecto.Changeset
-  alias Eventos.Events.{EventAccounts, Event}
-  alias Eventos.Accounts.Account
-
-  @primary_key false
-  schema "event_accounts" do
-    field :roles, :integer
-    belongs_to :event, Event
-    belongs_to :account, Account
-
-    timestamps()
-  end
-
-  @doc false
-  def changeset(%EventAccounts{} = event_accounts, attrs) do
-    event_accounts
-    |> cast(attrs, [:roles])
-    |> validate_required([:roles])
-  end
-end

lib/eventos/events/events.ex

@@ -7,6 +7,7 @@ defmodule Eventos.Events do
   alias Eventos.Repo
 
   alias Eventos.Events.Event
+  alias Eventos.Accounts.Account
 
   @doc """
   Returns the list of events.
@@ -294,195 +295,389 @@ defmodule Eventos.Events do
     Tag.changeset(tag, %{})
   end
 
-  alias Eventos.Events.EventAccounts
+  alias Eventos.Events.Participant
 
   @doc """
-  Returns the list of event_accounts.
+  Returns the list of participants.
 
   ## Examples
 
-      iex> list_event_accounts()
-      [%EventAccounts{}, ...]
+      iex> list_participants()
+      [%Participant{}, ...]
 
   """
-  def list_event_accounts do
-    Repo.all(EventAccounts)
+  def list_participants do
+    Repo.all(Participant)
   end
 
   @doc """
-  Gets a single event_accounts.
+  Gets a single participant.
 
-  Raises `Ecto.NoResultsError` if the Event accounts does not exist.
+  Raises `Ecto.NoResultsError` if the Participant does not exist.
 
   ## Examples
 
-      iex> get_event_accounts!(123)
-      %EventAccounts{}
+      iex> get_participant!(123)
+      %Participant{}
 
-      iex> get_event_accounts!(456)
+      iex> get_participant!(456)
       ** (Ecto.NoResultsError)
 
   """
-  def get_event_accounts!(id), do: Repo.get!(EventAccounts, id)
+  def get_participant!(event_id, account_id) do
+    Repo.get_by!(Participant, [event_id: event_id, account_id: account_id])
+  end
 
   @doc """
-  Creates a event_accounts.
+  Creates a participant.
 
   ## Examples
 
-      iex> create_event_accounts(%{field: value})
-      {:ok, %EventAccounts{}}
+      iex> create_participant(%{field: value})
+      {:ok, %Participant{}}
 
-      iex> create_event_accounts(%{field: bad_value})
+      iex> create_participant(%{field: bad_value})
       {:error, %Ecto.Changeset{}}
 
   """
-  def create_event_accounts(attrs \\ %{}) do
-    %EventAccounts{}
-    |> EventAccounts.changeset(attrs)
+  def create_participant(attrs \\ %{}) do
+    %Participant{}
+    |> Participant.changeset(attrs)
     |> Repo.insert()
   end
 
   @doc """
-  Updates a event_accounts.
+  Updates a participant.
 
   ## Examples
 
-      iex> update_event_accounts(event_accounts, %{field: new_value})
-      {:ok, %EventAccounts{}}
+      iex> update_participant(participant, %{field: new_value})
+      {:ok, %Participant{}}
 
-      iex> update_event_accounts(event_accounts, %{field: bad_value})
+      iex> update_participant(participant, %{field: bad_value})
       {:error, %Ecto.Changeset{}}
 
   """
-  def update_event_accounts(%EventAccounts{} = event_accounts, attrs) do
-    event_accounts
-    |> EventAccounts.changeset(attrs)
+  def update_participant(%Participant{} = participant, attrs) do
+    participant
+    |> Participant.changeset(attrs)
     |> Repo.update()
   end
 
   @doc """
-  Deletes a EventAccounts.
+  Deletes a Participant.
 
   ## Examples
 
-      iex> delete_event_accounts(event_accounts)
-      {:ok, %EventAccounts{}}
+      iex> delete_participant(participant)
+      {:ok, %Participant{}}
 
-      iex> delete_event_accounts(event_accounts)
+      iex> delete_participant(participant)
       {:error, %Ecto.Changeset{}}
 
   """
-  def delete_event_accounts(%EventAccounts{} = event_accounts) do
-    Repo.delete(event_accounts)
+  def delete_participant(%Participant{} = participant) do
+    Repo.delete(participant)
   end
 
   @doc """
-  Returns an `%Ecto.Changeset{}` for tracking event_accounts changes.
+  Returns an `%Ecto.Changeset{}` for tracking participant changes.
 
   ## Examples
 
-      iex> change_event_accounts(event_accounts)
-      %Ecto.Changeset{source: %EventAccounts{}}
+      iex> change_participant(participant)
+      %Ecto.Changeset{source: %Participant{}}
 
   """
-  def change_event_accounts(%EventAccounts{} = event_accounts) do
-    EventAccounts.changeset(event_accounts, %{})
+  def change_participant(%Participant{} = participant) do
+    Participant.changeset(participant, %{})
   end
 
-  alias Eventos.Events.EventRequest
+  alias Eventos.Events.Request
 
   @doc """
-  Returns the list of event_requests.
+  Returns the list of requests.
 
   ## Examples
 
-      iex> list_event_requests()
-      [%EventRequest{}, ...]
+      iex> list_requests()
+      [%Request{}, ...]
 
   """
-  def list_event_requests do
-    Repo.all(EventRequest)
+  def list_requests do
+    Repo.all(Request)
   end
 
   @doc """
-  Gets a single event_request.
+  Gets a single request.
 
-  Raises `Ecto.NoResultsError` if the Event request does not exist.
+  Raises `Ecto.NoResultsError` if the Request does not exist.
 
   ## Examples
 
-      iex> get_event_request!(123)
-      %EventRequest{}
+      iex> get_request!(123)
+      %Request{}
 
-      iex> get_event_request!(456)
+      iex> get_request!(456)
       ** (Ecto.NoResultsError)
 
   """
-  def get_event_request!(id), do: Repo.get!(EventRequest, id)
+  def get_request!(id), do: Repo.get!(Request, id)
 
   @doc """
-  Creates a event_request.
+  Creates a request.
 
   ## Examples
 
-      iex> create_event_request(%{field: value})
-      {:ok, %EventRequest{}}
+      iex> create_request(%{field: value})
+      {:ok, %Request{}}
 
-      iex> create_event_request(%{field: bad_value})
+      iex> create_request(%{field: bad_value})
       {:error, %Ecto.Changeset{}}
 
   """
-  def create_event_request(attrs \\ %{}) do
-    %EventRequest{}
-    |> EventRequest.changeset(attrs)
+  def create_request(attrs \\ %{}) do
+    %Request{}
+    |> Request.changeset(attrs)
     |> Repo.insert()
   end
 
   @doc """
-  Updates a event_request.
+  Updates a request.
 
   ## Examples
 
-      iex> update_event_request(event_request, %{field: new_value})
-      {:ok, %EventRequest{}}
+      iex> update_request(request, %{field: new_value})
+      {:ok, %Request{}}
 
-      iex> update_event_request(event_request, %{field: bad_value})
+      iex> update_request(request, %{field: bad_value})
       {:error, %Ecto.Changeset{}}
 
   """
-  def update_event_request(%EventRequest{} = event_request, attrs) do
-    event_request
-    |> EventRequest.changeset(attrs)
+  def update_request(%Request{} = request, attrs) do
+    request
+    |> Request.changeset(attrs)
     |> Repo.update()
   end
 
   @doc """
-  Deletes a EventRequest.
+  Deletes a Request.
 
   ## Examples
 
-      iex> delete_event_request(event_request)
-      {:ok, %EventRequest{}}
+      iex> delete_request(request)
+      {:ok, %Request{}}
 
-      iex> delete_event_request(event_request)
+      iex> delete_request(request)
       {:error, %Ecto.Changeset{}}
 
   """
-  def delete_event_request(%EventRequest{} = event_request) do
-    Repo.delete(event_request)
+  def delete_request(%Request{} = request) do
+    Repo.delete(request)
   end
 
   @doc """
-  Returns an `%Ecto.Changeset{}` for tracking event_request changes.
+  Returns an `%Ecto.Changeset{}` for tracking request changes.
 
   ## Examples
 
-      iex> change_event_request(event_request)
-      %Ecto.Changeset{source: %EventRequest{}}
+      iex> change_request(request)
+      %Ecto.Changeset{source: %Request{}}
 
   """
-  def change_event_request(%EventRequest{} = event_request) do
-    EventRequest.changeset(event_request, %{})
+  def change_request(%Request{} = request) do
+    Request.changeset(request, %{})
+  end
+
+  alias Eventos.Events.Session
+
+  @doc """
+  Returns the list of sessions.
+
+  ## Examples
+
+      iex> list_sessions()
+      [%Session{}, ...]
+
+  """
+  def list_sessions do
+    Repo.all(Session)
+  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 Eventos.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
 end

lib/eventos/events/participant.ex

@@ -0,0 +1,22 @@
+defmodule Eventos.Events.Participant do
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Eventos.Events.{Participant, Event}
+  alias Eventos.Accounts.Account
+
+  @primary_key false
+  schema "participants" do
+    field :role, :integer
+    belongs_to :event, Event, primary_key: true
+    belongs_to :account, Account, primary_key: true
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(%Participant{} = participant, attrs) do
+    participant
+    |> cast(attrs, [:role, :event_id, :account_id])
+    |> validate_required([:role, :event_id, :account_id])
+  end
+end

lib/eventos/events/request.ex

@@ -1,21 +1,20 @@
-defmodule Eventos.Events.EventRequest do
+defmodule Eventos.Events.Request do
   use Ecto.Schema
   import Ecto.Changeset
-  alias Eventos.Events.{EventRequest, Event}
+  alias Eventos.Events.{Request, Event}
   alias Eventos.Accounts.Account
 
-
   schema "event_requests" do
     field :state, :integer
-    has_one :event_id, Event
-    has_one :account_id, Account
+    belongs_to :event, Event
+    belongs_to :account, Account
 
     timestamps()
   end
 
   @doc false
-  def changeset(%EventRequest{} = event_request, attrs) do
-    event_request
+  def changeset(%Request{} = request, attrs) do
+    request
     |> cast(attrs, [:state])
     |> validate_required([:state])
   end

lib/eventos/events/session.ex

@@ -0,0 +1,30 @@
+defmodule Eventos.Events.Session do
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Eventos.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/eventos/events/tag.ex

@@ -1,12 +1,49 @@
+defmodule Eventos.Events.Tag.TitleSlug do
+  alias Eventos.Events.Tag
+  import Ecto.Query
+  alias Eventos.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
+        |> increment_slug
+        |> build_unique_slug(changeset)
+    end
+  end
+
+  defp 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
+
 defmodule Eventos.Events.Tag do
   use Ecto.Schema
   import Ecto.Changeset
   alias Eventos.Events.Tag
-
+  alias Eventos.Events.Tag.TitleSlug
 
   schema "tags" do
-    field :slug, :string
     field :title, :string
+    field :slug, TitleSlug.Type
 
     timestamps()
   end
@@ -14,8 +51,9 @@ defmodule Eventos.Events.Tag do
   @doc false
   def changeset(%Tag{} = tag, attrs) do
     tag
-    |> cast(attrs, [:title, :slug])
-    |> validate_required([:title, :slug])
-    |> unique_constraint(:slug)
+    |> cast(attrs, [:title])
+    |> validate_required([:title])
+    |> TitleSlug.maybe_generate_slug()
+    |> TitleSlug.unique_constraint()
   end
-end
+end

lib/eventos/events/track.ex

@@ -0,0 +1,23 @@
+defmodule Eventos.Events.Track do
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Eventos.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