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

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

lib/eventos/accounts/account.ex

@@ -1,22 +1,23 @@
 defmodule Eventos.Accounts.Account do
   use Ecto.Schema
   import Ecto.Changeset
-  alias Eventos.Accounts.{Account, GroupAccount, GroupRequest, Group, User}
+  alias Eventos.Accounts.{Account, User}
+  alias Eventos.Groups.{Group, Member, Request}
   alias Eventos.Events.Event
 
   schema "accounts" do
-    field :username, :string
     field :description, :string
     field :display_name, :string
-    field :domain, :string, default: nil
+    field :domain, :string
     field :private_key, :string
     field :public_key, :string
     field :suspended, :boolean, default: false
     field :uri, :string
     field :url, :string
-    has_many :organized_events, Event
-    many_to_many :groups, Group, join_through: GroupAccount
-    has_many :group_request, GroupRequest
+    field :username, :string
+    has_many :organized_events, Event, [foreign_key: :organizer_id]
+    many_to_many :groups, Group, join_through: Member
+    has_many :group_request, Request
     has_one :user, User
 
     timestamps()
@@ -26,7 +27,14 @@ defmodule Eventos.Accounts.Account do
   def changeset(%Account{} = account, attrs) do
     account
     |> cast(attrs, [:username, :domain, :display_name, :description, :private_key, :public_key, :suspended, :uri, :url])
-    |> validate_required([:username, :display_name, :description, :private_key, :public_key, :suspended])
+    |> validate_required([:username, :public_key, :suspended, :uri, :url])
     |> unique_constraint(:username, name: :accounts_username_domain_index)
   end
+
+  def registration_changeset(%Account{} = account, attrs) do
+    account
+    |> cast(attrs, [:username, :domain, :display_name, :description, :private_key, :public_key, :suspended, :uri, :url])
+    |> validate_required([:username, :public_key, :suspended, :uri, :url])
+    |> unique_constraint(:username)
+  end
 end

lib/eventos/accounts/accounts.ex

@@ -4,130 +4,8 @@ defmodule Eventos.Accounts do
   """
 
   import Ecto.Query, warn: false
-  import Logger
   alias Eventos.Repo
-
-  alias Eventos.Accounts.User
-
-  @doc """
-  Returns the list of users.
-
-  ## Examples
-
-      iex> list_users()
-      [%User{}, ...]
-
-  """
-  def list_users do
-    Repo.all(User)
-  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)
-
-
-  @doc """
-  Get an user by email
-  """
-  def find(email) do
-    Repo.get_by!(User, email: email)
-  end
-
-  @doc """
-  Authenticate user
-  """
-  def authenticate(%{user: user, password: password}) do
-    # Does password match the one stored in the database?
-    Logger.debug(user.password_hash)
-    Logger.debug(password)
-    case Comeonin.Argon2.checkpw(password, user.password_hash) do
-      true ->
-        # Yes, create and return the token
-        EventosWeb.Guardian.encode_and_sign(user)
-      _ ->
-        # No, return an error
-        {:error, :unauthorized}
-    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.changeset(attrs)
-    |> Repo.insert()
-  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
+  import Logger
 
   alias Eventos.Accounts.Account
 
@@ -158,7 +36,14 @@ defmodule Eventos.Accounts do
       ** (Ecto.NoResultsError)
 
   """
-  def get_account!(id), do: Repo.get!(Account, id)
+  def get_account!(id) do
+    account = Repo.get!(Account, id)
+  end
+
+  def get_account_with_everything!(id) do
+    account = Repo.get!(Account, id)
+    |> Repo.preload :organized_events
+  end
 
   @doc """
   Creates a account.
@@ -225,291 +110,177 @@ defmodule Eventos.Accounts do
     Account.changeset(account, %{})
   end
 
-  alias Eventos.Accounts.Group
+  alias Eventos.Accounts.User
 
   @doc """
-  Returns the list of groups.
+  Returns the list of users.
 
   ## Examples
 
-      iex> list_groups()
-      [%Group{}, ...]
+      iex> list_users()
+      [%User{}, ...]
 
   """
-  def list_groups do
-    Repo.all(Group)
+  def list_users do
+    Repo.all(User)
+  end
+
+  def list_users_with_accounts do
+    Repo.all(User)
+    |> Repo.preload :account
   end
 
   @doc """
-  Gets a single group.
+  Gets a single user.
 
-  Raises `Ecto.NoResultsError` if the Group does not exist.
+  Raises `Ecto.NoResultsError` if the User does not exist.
 
   ## Examples
 
-      iex> get_group!(123)
-      %Group{}
+      iex> get_user!(123)
+      %User{}
 
-      iex> get_group!(456)
+      iex> get_user!(456)
       ** (Ecto.NoResultsError)
 
   """
-  def get_group!(id), do: Repo.get!(Group, id)
+  def get_user!(id), do: Repo.get!(User, id)
+
+  def get_user_with_account!(id) do
+    Repo.get!(User, id)
+    |> Repo.preload :account
+  end
 
   @doc """
-  Creates a group.
+  Get an user by email
+  """
+  def find_by_email(email) do
+    user = Repo.get_by(User, email: email)
+    |> Repo.preload :account
+  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
+        EventosWeb.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
+    {:ok, {privkey, pubkey}} = RsaEx.generate_keypair("4096")
+
+
+    account = Eventos.Accounts.Account.registration_changeset(%Eventos.Accounts.Account{}, %{
+      username: username,
+      domain: nil,
+      private_key: privkey,
+      public_key: pubkey,
+      uri: "h",
+      url: "h"
+    })
+
+    user = Eventos.Accounts.User.registration_changeset(%Eventos.Accounts.User{}, %{
+      email: email,
+      password: password
+    })
+
+
+    account_with_user = Ecto.Changeset.put_assoc(account, :user, user)
+
+    try do
+      coucou = Eventos.Repo.insert!(account_with_user)
+      user = find_by_email(email)
+      {:ok, user}
+    rescue
+     e in Ecto.InvalidChangesetError ->
+      Logger.debug(inspect e)
+      {:error, e.changeset.changes.user.errors}
+    end
+
+#    with {:ok, %Account{} = account} <- create_account(%{username: username, suspended: false, domain: nil, private_key: privkey, public_key: pubkey, uri: "h", url: "h"}) do
+#      case create_user(%{email: email, password: password, account: account}) do
+#        {:ok, %User{} = user } ->
+#          {:ok, user}
+#        {:error, %Ecto.Changeset{} = changeset} ->
+#          {:error, changeset}
+#      end
+#    end
+  end
+
+
+  @doc """
+  Creates a user.
 
   ## Examples
 
-      iex> create_group(%{field: value})
-      {:ok, %Group{}}
+      iex> create_user(%{field: value})
+      {:ok, %User{}}
 
-      iex> create_group(%{field: bad_value})
+      iex> create_user(%{field: bad_value})
       {:error, %Ecto.Changeset{}}
 
   """
-  def create_group(attrs \\ %{}) do
-    %Group{}
-    |> Group.changeset(attrs)
+  def create_user(attrs \\ %{}) do
+    %User{}
+    |> User.registration_changeset(attrs)
     |> Repo.insert()
   end
 
   @doc """
-  Updates a group.
+  Updates a user.
 
   ## Examples
 
-      iex> update_group(group, %{field: new_value})
-      {:ok, %Group{}}
+      iex> update_user(user, %{field: new_value})
+      {:ok, %User{}}
 
-      iex> update_group(group, %{field: bad_value})
+      iex> update_user(user, %{field: bad_value})
       {:error, %Ecto.Changeset{}}
 
   """
-  def update_group(%Group{} = group, attrs) do
-    group
-    |> Group.changeset(attrs)
+  def update_user(%User{} = user, attrs) do
+    user
+    |> User.changeset(attrs)
     |> Repo.update()
   end
 
   @doc """
-  Deletes a Group.
+  Deletes a User.
 
   ## Examples
 
-      iex> delete_group(group)
-      {:ok, %Group{}}
+      iex> delete_user(user)
+      {:ok, %User{}}
 
-      iex> delete_group(group)
+      iex> delete_user(user)
       {:error, %Ecto.Changeset{}}
 
   """
-  def delete_group(%Group{} = group) do
-    Repo.delete(group)
+  def delete_user(%User{} = user) do
+    Repo.delete(user)
   end
 
   @doc """
-  Returns an `%Ecto.Changeset{}` for tracking group changes.
+  Returns an `%Ecto.Changeset{}` for tracking user changes.
 
   ## Examples
 
-      iex> change_group(group)
-      %Ecto.Changeset{source: %Group{}}
+      iex> change_user(user)
+      %Ecto.Changeset{source: %User{}}
 
   """
-  def change_group(%Group{} = group) do
-    Group.changeset(group, %{})
-  end
-
-  alias Eventos.Accounts.GroupAccount
-
-  @doc """
-  Returns the list of group_accounts.
-
-  ## Examples
-
-      iex> list_group_accounts()
-      [%GroupAccount{}, ...]
-
-  """
-  def list_group_accounts do
-    Repo.all(GroupAccount)
-  end
-
-  @doc """
-  Gets a single group_account.
-
-  Raises `Ecto.NoResultsError` if the Group account does not exist.
-
-  ## Examples
-
-      iex> get_group_account!(123)
-      %GroupAccount{}
-
-      iex> get_group_account!(456)
-      ** (Ecto.NoResultsError)
-
-  """
-  def get_group_account!(id), do: Repo.get!(GroupAccount, id)
-
-  @doc """
-  Creates a group_account.
-
-  ## Examples
-
-      iex> create_group_account(%{field: value})
-      {:ok, %GroupAccount{}}
-
-      iex> create_group_account(%{field: bad_value})
-      {:error, %Ecto.Changeset{}}
-
-  """
-  def create_group_account(attrs \\ %{}) do
-    %GroupAccount{}
-    |> GroupAccount.changeset(attrs)
-    |> Repo.insert()
-  end
-
-  @doc """
-  Updates a group_account.
-
-  ## Examples
-
-      iex> update_group_account(group_account, %{field: new_value})
-      {:ok, %GroupAccount{}}
-
-      iex> update_group_account(group_account, %{field: bad_value})
-      {:error, %Ecto.Changeset{}}
-
-  """
-  def update_group_account(%GroupAccount{} = group_account, attrs) do
-    group_account
-    |> GroupAccount.changeset(attrs)
-    |> Repo.update()
-  end
-
-  @doc """
-  Deletes a GroupAccount.
-
-  ## Examples
-
-      iex> delete_group_account(group_account)
-      {:ok, %GroupAccount{}}
-
-      iex> delete_group_account(group_account)
-      {:error, %Ecto.Changeset{}}
-
-  """
-  def delete_group_account(%GroupAccount{} = group_account) do
-    Repo.delete(group_account)
-  end
-
-  @doc """
-  Returns an `%Ecto.Changeset{}` for tracking group_account changes.
-
-  ## Examples
-
-      iex> change_group_account(group_account)
-      %Ecto.Changeset{source: %GroupAccount{}}
-
-  """
-  def change_group_account(%GroupAccount{} = group_account) do
-    GroupAccount.changeset(group_account, %{})
-  end
-
-  alias Eventos.Accounts.GroupRequest
-
-  @doc """
-  Returns the list of group_request.
-
-  ## Examples
-
-      iex> list_group_requests()
-      [%GroupRequest{}, ...]
-
-  """
-  def list_group_requests do
-    Repo.all(GroupRequest)
-  end
-
-  @doc """
-  Gets a single group_request.
-
-  Raises `Ecto.NoResultsError` if the Group request does not exist.
-
-  ## Examples
-
-      iex> get_group_request!(123)
-      %GroupRequest{}
-
-      iex> get_group_request!(456)
-      ** (Ecto.NoResultsError)
-
-  """
-  def get_group_request!(id), do: Repo.get!(GroupRequest, id)
-
-  @doc """
-  Creates a group_request.
-
-  ## Examples
-
-      iex> create_group_request(%{field: value})
-      {:ok, %GroupRequest{}}
-
-      iex> create_group_request(%{field: bad_value})
-      {:error, %Ecto.Changeset{}}
-
-  """
-  def create_group_request(attrs \\ %{}) do
-    %GroupRequest{}
-    |> GroupRequest.changeset(attrs)
-    |> Repo.insert()
-  end
-
-  @doc """
-  Updates a group_request.
-
-  ## Examples
-
-      iex> update_group_request(group_request, %{field: new_value})
-      {:ok, %GroupRequest{}}
-
-      iex> update_group_request(group_request, %{field: bad_value})
-      {:error, %Ecto.Changeset{}}
-
-  """
-  def update_group_request(%GroupRequest{} = group_request, attrs) do
-    group_request
-    |> GroupRequest.changeset(attrs)
-    |> Repo.update()
-  end
-
-  @doc """
-  Deletes a GroupRequest.
-
-  ## Examples
-
-      iex> delete_group_request(group_request)
-      {:ok, %GroupRequest{}}
-
-      iex> delete_group_request(group_request)
-      {:error, %Ecto.Changeset{}}
-
-  """
-  def delete_group_request(%GroupRequest{} = group_request) do
-    Repo.delete(group_request)
-  end
-
-  @doc """
-  Returns an `%Ecto.Changeset{}` for tracking group_request changes.
-
-  ## Examples
-
-      iex> change_group_request(group_request)
-      %Ecto.Changeset{source: %GroupRequest{}}
-
-  """
-  def change_group_request(%GroupRequest{} = group_request) do
-    GroupRequest.changeset(group_request, %{})
+  def change_user(%User{} = user) do
+    User.changeset(user, %{})
   end
 end

lib/eventos/accounts/group.ex

@@ -1,25 +0,0 @@
-defmodule Eventos.Accounts.Group do
-  use Ecto.Schema
-  import Ecto.Changeset
-  alias Eventos.Accounts.{Group, Account, GroupAccount, GroupRequest}
-
-
-  schema "groups" do
-    field :description, :string
-    field :suspended, :boolean, default: false
-    field :title, :string
-    field :uri, :string
-    field :url, :string
-    many_to_many :accounts, Account, join_through: GroupAccount
-    has_many :requests, GroupRequest
-
-    timestamps()
-  end
-
-  @doc false
-  def changeset(%Group{} = group, attrs) do
-    group
-    |> cast(attrs, [:title, :description, :suspended, :url, :uri])
-    |> validate_required([:title, :description, :suspended, :url, :uri])
-  end
-end

lib/eventos/accounts/user.ex

@@ -2,24 +2,22 @@ defmodule Eventos.Accounts.User do
   use Ecto.Schema
   import Ecto.Changeset
   alias Eventos.Accounts.{Account, User}
-  alias Eventos.Repo
 
-  import Logger
 
   schema "users" do
     field :email, :string
-    field :role, :integer, default: 0
-    field :password, :string, virtual: true
     field :password_hash, :string
+    field :password, :string, virtual: true
+    field :role, :integer, default: 0
     belongs_to :account, Account
+
     timestamps()
   end
 
-
   @doc false
   def changeset(%User{} = user, attrs) do
     user
-    |> cast(attrs, [:email, :password_hash])
+    |> cast(attrs, [:email, :role, :password_hash, :account_id])
     |> validate_required([:email])
     |> unique_constraint(:email)
     |> validate_format(:email, ~r/@/)
@@ -44,4 +42,5 @@ defmodule Eventos.Accounts.User do
         changeset
     end
   end
+
 end

lib/eventos/application.ex

@@ -14,6 +14,7 @@ defmodule Eventos.Application do
       supervisor(EventosWeb.Endpoint, []),
       # Start your own worker by calling: Eventos.Worker.start_link(arg1, arg2, arg3)
       # worker(Eventos.Worker, [arg1, arg2, arg3]),
+      worker(Guardian.DB.Token.SweeperServer, [])
     ]
 
     # See https://hexdocs.pm/elixir/Supervisor.html

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

lib/eventos/groups/group.ex

@@ -0,0 +1,66 @@
+defmodule Eventos.Groups.Group.TitleSlug do
+  alias Eventos.Groups.Group
+  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 g in Group,
+                 where: g.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.Groups.Group do
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Eventos.Groups.{Group, Member, Request}
+  alias Eventos.Accounts.Account
+  alias Eventos.Groups.Group.TitleSlug
+
+  schema "groups" do
+    field :description, :string
+    field :suspended, :boolean, default: false
+    field :title, :string
+    field :slug, TitleSlug.Type
+    field :uri, :string
+    field :url, :string
+    many_to_many :accounts, Account, join_through: Member
+    has_many :requests, Request
+
+    timestamps()
+  end
+
+  @doc false
+  def changeset(%Group{} = group, attrs) do
+    group
+    |> cast(attrs, [:title, :description, :suspended, :url, :uri])
+    |> validate_required([:title, :description, :suspended, :url, :uri])
+    |> TitleSlug.maybe_generate_slug()
+    |> TitleSlug.unique_constraint()
+  end
+end

lib/eventos/groups/groups.ex

@@ -0,0 +1,296 @@
+defmodule Eventos.Groups do
+  @moduledoc """
+  The Groups context.
+  """
+
+  import Ecto.Query, warn: false
+  alias Eventos.Repo
+
+  alias Eventos.Groups.Group
+
+  @doc """
+  Returns the list of groups.
+
+  ## Examples
+
+      iex> list_groups()
+      [%Group{}, ...]
+
+  """
+  def list_groups do
+    Repo.all(Group)
+  end
+
+  @doc """
+  Gets a single group.
+
+  Raises `Ecto.NoResultsError` if the Group does not exist.
+
+  ## Examples
+
+      iex> get_group!(123)
+      %Group{}
+
+      iex> get_group!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_group!(id), do: Repo.get!(Group, id)
+
+  @doc """
+  Creates a group.
+
+  ## Examples
+
+      iex> create_group(%{field: value})
+      {:ok, %Group{}}
+
+      iex> create_group(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_group(attrs \\ %{}) do
+    %Group{}
+    |> Group.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a group.
+
+  ## Examples
+
+      iex> update_group(group, %{field: new_value})
+      {:ok, %Group{}}
+
+      iex> update_group(group, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_group(%Group{} = group, attrs) do
+    group
+    |> Group.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a Group.
+
+  ## Examples
+
+      iex> delete_group(group)
+      {:ok, %Group{}}
+
+      iex> delete_group(group)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_group(%Group{} = group) do
+    Repo.delete(group)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking group changes.
+
+  ## Examples
+
+      iex> change_group(group)
+      %Ecto.Changeset{source: %Group{}}
+
+  """
+  def change_group(%Group{} = group) do
+    Group.changeset(group, %{})
+  end
+
+  alias Eventos.Groups.Member
+
+  @doc """
+  Returns the list of members.
+
+  ## Examples
+
+      iex> list_members()
+      [%Member{}, ...]
+
+  """
+  def list_members do
+    Repo.all(Member)
+  end
+
+  @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
+    %Member{}
+    |> Member.changeset(attrs)
+    |> Repo.insert()
+  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
+
+  alias Eventos.Groups.Request
+
+  @doc """
+  Returns the list of requests.
+
+  ## Examples
+
+      iex> list_requests()
+      [%Request{}, ...]
+
+  """
+  def list_requests do
+    Repo.all(Request)
+  end
+
+  @doc """
+  Gets a single request.
+
+  Raises `Ecto.NoResultsError` if the Request does not exist.
+
+  ## Examples
+
+      iex> get_request!(123)
+      %Request{}
+
+      iex> get_request!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_request!(id), do: Repo.get!(Request, id)
+
+  @doc """
+  Creates a request.
+
+  ## Examples
+
+      iex> create_request(%{field: value})
+      {:ok, %Request{}}
+
+      iex> create_request(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_request(attrs \\ %{}) do
+    %Request{}
+    |> Request.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a request.
+
+  ## Examples
+
+      iex> update_request(request, %{field: new_value})
+      {:ok, %Request{}}
+
+      iex> update_request(request, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_request(%Request{} = request, attrs) do
+    request
+    |> Request.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a Request.
+
+  ## Examples
+
+      iex> delete_request(request)
+      {:ok, %Request{}}
+
+      iex> delete_request(request)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_request(%Request{} = request) do
+    Repo.delete(request)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking request changes.
+
+  ## Examples
+
+      iex> change_request(request)
+      %Ecto.Changeset{source: %Request{}}
+
+  """
+  def change_request(%Request{} = request) do
+    Request.changeset(request, %{})
+  end
+end

lib/eventos/groups/member.ex

@@ -1,10 +1,11 @@
-defmodule Eventos.Accounts.GroupAccount do
+defmodule Eventos.Groups.Member do
   use Ecto.Schema
   import Ecto.Changeset
-  alias Eventos.Accounts.{GroupAccount, Account, Group}
+  alias Eventos.Groups.{Member, Group}
+  alias Eventos.Accounts.Account
 
-  @primary_key false
-  schema "group_accounts" do
+
+  schema "members" do
     field :role, :integer
     belongs_to :group, Group
     belongs_to :account, Account
@@ -13,8 +14,8 @@ defmodule Eventos.Accounts.GroupAccount do
   end
 
   @doc false
-  def changeset(%GroupAccount{} = group_account, attrs) do
-    group_account
+  def changeset(%Member{} = member, attrs) do
+    member
     |> cast(attrs, [:role])
     |> validate_required([:role])
   end

lib/eventos/groups/request.ex

@@ -1,7 +1,8 @@
-defmodule Eventos.Accounts.GroupRequest do
+defmodule Eventos.Groups.Request do
   use Ecto.Schema
   import Ecto.Changeset
-  alias Eventos.Accounts.{GroupRequest}
+  alias Eventos.Groups.Request
+
 
   schema "group_requests" do
     field :state, :integer
@@ -12,8 +13,8 @@ defmodule Eventos.Accounts.GroupRequest do
   end
 
   @doc false
-  def changeset(%GroupRequest{} = group_request, attrs) do
-    group_request
+  def changeset(%Request{} = request, attrs) do
+    request
     |> cast(attrs, [:state])
     |> validate_required([:state])
   end

lib/eventos/postgrex_types.ex

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