User invites

lib/code_corps/accounts/accounts.ex

@@ -6,6 +6,7 @@ defmodule CodeCorps.Accounts do
   """
 
   alias CodeCorps.{
+    Accounts,
     Accounts.Changesets,
     Comment,
     GitHub.Adapters,
@@ -14,12 +15,28 @@ defmodule CodeCorps.Accounts do
     Processor,
     Task,
     User,
+    UserInvite,
     Repo
   }
   alias Ecto.{Changeset, Multi}
 
   import Ecto.Query
 
+  @doc ~S"""
+  Creates a `CodeCorps.User` account when such a request is made from the client
+  application.
+
+  If an `invite_id` attribute is provided in the request, treats the process as
+  claiming the specified invite.
+  """
+  @spec create(map) :: {:ok, User.t} | {:error, Changeset.t} | {:error, :invite_not_found}
+  def create(%{"invite_id" => _} = params) do
+    params |> Accounts.UserInvites.claim_invite()
+  end
+  def create(%{} = params) do
+    %User{} |> User.registration_changeset(params) |> Repo.insert()
+  end
+
   @doc ~S"""
   Creates a user record using attributes from a GitHub payload.
   """
@@ -184,4 +201,7 @@ defmodule CodeCorps.Accounts do
     |> Repo.update_all(updates, update_options)
     |> (fn {_count, comments} -> {:ok, comments} end).()
   end
+
+  @spec create_invite(map) :: {:ok, UserInvite.t} | {:error, Changeset.t}
+  defdelegate create_invite(params), to: Accounts.UserInvites
 end

lib/code_corps/accounts/user_invites.ex

@@ -0,0 +1,114 @@
+defmodule CodeCorps.Accounts.UserInvites do
+  @moduledoc ~S"""
+  Subcontext for managing of `UserInvite` records
+  """
+
+  alias CodeCorps.{Project, ProjectUser, Repo, User, UserInvite}
+  alias Ecto.{Changeset, Multi}
+
+  @spec create_invite(map) :: {:ok, UserInvite.t()} | {:error, Changeset.t()}
+  def create_invite(%{} = params) do
+    %UserInvite{}
+    |> Changeset.cast(params, [:email, :name, :role, :inviter_id, :project_id])
+    |> Changeset.validate_required([:email, :inviter_id])
+    |> Changeset.validate_inclusion(:role, ProjectUser.roles())
+    |> Changeset.assoc_constraint(:inviter)
+    |> Changeset.assoc_constraint(:project)
+    |> ensure_email_not_owned_by_user()
+    |> ensure_role_and_project()
+    |> Repo.insert()
+  end
+
+  @spec ensure_email_not_owned_by_user(Changeset.t()) :: Changeset.t()
+  defp ensure_email_not_owned_by_user(%Changeset{changes: %{email: email}} = changeset)
+       when not is_nil(email) do
+    if User |> Repo.get_by(email: email) do
+      changeset |> Changeset.add_error(:email, "Already associated with a user")
+    else
+      changeset
+    end
+  end
+
+  defp ensure_email_not_owned_by_user(%Changeset{} = changeset), do: changeset
+
+  @spec ensure_role_and_project(Changeset.t()) :: Changeset.t()
+  defp ensure_role_and_project(%Changeset{} = changeset) do
+    changes = [
+      changeset |> Changeset.get_field(:role),
+      changeset |> Changeset.get_field(:project_id)
+    ]
+
+    case changes do
+      [nil, nil] ->
+        changeset
+
+      [nil, _project_id] ->
+        changeset |> Changeset.add_error(:role, "Needs to be specified for a project invite")
+
+      [_role, nil] ->
+        changeset
+        |> Changeset.add_error(:project_id, "Needs to be specified for a project invite")
+
+      [_role, _project_id] ->
+        changeset
+    end
+  end
+
+  @spec claim_invite(map) :: {:ok, User.t()}
+  def claim_invite(%{} = params) do
+    Multi.new()
+    |> Multi.run(:load_invite, fn %{} -> params |> load_invite() end)
+    |> Multi.run(:user, fn %{} -> params |> claim_new_user() end)
+    |> Multi.run(:project_user, fn %{user: user, load_invite: user_invite} ->
+      user |> join_project(user_invite)
+    end)
+    |> Multi.run(:user_invite, fn %{user: user, load_invite: user_invite} ->
+      user_invite |> associate_invitee(user)
+    end)
+    |> Repo.transaction()
+    |> marshall_response()
+  end
+
+  @spec load_invite(map) :: {:ok, UserInvite.t()} | {:error, :not_found}
+  defp load_invite(%{"invite_id" => invite_id}) do
+    case UserInvite |> Repo.get(invite_id) |> Repo.preload([:invitee, :project]) do
+      nil -> {:error, :not_found}
+      %UserInvite{} = invite -> {:ok, invite}
+    end
+  end
+
+  defp load_invite(%{}), do: {:error, :not_found}
+
+  @spec claim_new_user(map) :: {:ok, User.t()}
+  defp claim_new_user(%{} = params) do
+    %User{} |> User.registration_changeset(params) |> Repo.insert()
+  end
+
+  @spec join_project(User.t(), UserInvite.t()) :: {:ok, ProjectUser.t()} | {:error, Changeset.t()}
+  defp join_project(%User{} = user, %UserInvite{role: role, project: %Project{} = project}) do
+    %ProjectUser{}
+    |> Changeset.change(%{role: role})
+    |> Changeset.put_assoc(:project, project)
+    |> Changeset.put_assoc(:user, user)
+    |> Changeset.unique_constraint(:project, name: :project_users_user_id_project_id_index)
+    |> Repo.insert()
+  end
+
+  defp join_project(%User{}, %UserInvite{}), do: {:ok, nil}
+
+  @spec associate_invitee(UserInvite.t(), User.t()) :: {:ok, UserInvite.t()}
+  defp associate_invitee(%UserInvite{invitee: nil} = invite, %User{} = user) do
+    invite
+    |> Changeset.change(%{})
+    |> Changeset.put_assoc(:invitee, user)
+    |> Repo.update()
+  end
+
+  @spec marshall_response(tuple) :: tuple
+  defp marshall_response({:ok, %{user: user, user_invite: user_invite}}) do
+    {:ok, user |> Map.put(:claimed_invite, user_invite)}
+  end
+  defp marshall_response({:error, :load_invite, :not_found, _}), do: {:error, :invite_not_found}
+  defp marshall_response({:error, :user, %Changeset{} = changeset, _}), do: {:error, changeset}
+  defp marshall_response(other_tuple), do: other_tuple
+end

lib/code_corps/analytics/segment_traits_builder.ex

@@ -42,7 +42,7 @@ defmodule CodeCorps.Analytics.SegmentTraitsBuilder do
       record
       |> Repo.preload([:project])
       |> Map.get(:project)
-      |> (&(&1 || %{})).()
+      |> blank_map_if_nil()
       |> Map.get(:title, "")
 
     %{
@@ -202,6 +202,20 @@ defmodule CodeCorps.Analytics.SegmentTraitsBuilder do
       category_id: user_category.category.id
     }
   end
+  defp traits(%CodeCorps.UserInvite{} = user_invite) do
+    user_invite = user_invite |> Repo.preload([:project, :inviter, :invitee])
+    %{
+      email: user_invite.email,
+      invitee: user_invite |> Map.get(:invitee) |> blank_map_if_nil() |> Map.get(:username),
+      invitee_id: user_invite.invitee_id,
+      inviter: user_invite.inviter.username,
+      inviter_id: user_invite.inviter_id,
+      name: user_invite.name,
+      project: user_invite |> Map.get(:project)|> blank_map_if_nil() |> Map.get(:title),
+      project_id: user_invite.project_id,
+      role: user_invite.role
+    }
+  end
   defp traits(%CodeCorps.UserRole{} = user_role) do
     user_role = user_role |> Repo.preload(:role)
     %{
@@ -225,4 +239,8 @@ defmodule CodeCorps.Analytics.SegmentTraitsBuilder do
     }
   end
   defp traits(%{token: _, user_id: _}), do: %{}
+
+  @spec blank_map_if_nil(struct | nil) :: struct | map
+  defp blank_map_if_nil(nil), do: %{}
+  defp blank_map_if_nil(struct), do: struct
 end

lib/code_corps/model/project_user.ex

@@ -8,15 +8,14 @@ defmodule CodeCorps.ProjectUser do
   @type t :: %__MODULE__{}
 
   schema "project_users" do
-    field :role, :string
+    field(:role, :string)
 
-    belongs_to :project, CodeCorps.Project
-    belongs_to :user, CodeCorps.User
+    belongs_to(:project, CodeCorps.Project)
+    belongs_to(:user, CodeCorps.User)
 
     timestamps()
   end
 
-
   @doc """
   Builds a changeset to create a pending membership
   """
@@ -55,7 +54,11 @@ defmodule CodeCorps.ProjectUser do
     |> validate_inclusion(:role, roles())
   end
 
-  defp roles do
-    ~w{ pending contributor admin owner }
+  @doc ~S"""
+  Returns supported project user role types
+  """
+  @spec roles :: list(String.t())
+  def roles do
+    ~w{pending contributor admin owner}
   end
 end

lib/code_corps/model/user.ex

@@ -40,6 +40,7 @@ defmodule CodeCorps.User do
     field :username, :string
     field :website, :string
 
+    has_one :claimed_invite, CodeCorps.UserInvite, foreign_key: :invitee_id
     has_one :github_app_installation, CodeCorps.GithubAppInstallation
     has_one :slugged_route, SluggedRoute
 

lib/code_corps/model/user_invite.ex

@@ -0,0 +1,17 @@
+defmodule CodeCorps.UserInvite do
+  use CodeCorps.Model
+
+  @type t :: %__MODULE__{}
+
+  schema "user_invites" do
+    field(:email, :string, null: false)
+    field(:role, :string)
+    field(:name, :string)
+
+    belongs_to(:project, CodeCorps.Project)
+    belongs_to(:inviter, CodeCorps.User)
+    belongs_to(:invitee, CodeCorps.User)
+
+    timestamps()
+  end
+end

lib/code_corps/policy/conversation_part.ex

@@ -1,7 +1,7 @@
 defmodule CodeCorps.Policy.ConversationPart do
   @moduledoc ~S"""
-  Handles `CodeCorps.User` authorization of actions on `CodeCorps.Conversation`
-  records.
+  Handles `CodeCorps.User` authorization of actions on
+  `CodeCorps.ConversationPart` records.
   """
 
   import CodeCorps.Policy.Helpers,

lib/code_corps/policy/policy.ex

@@ -34,6 +34,7 @@ defmodule CodeCorps.Policy do
     TaskSkill,
     User,
     UserCategory,
+    UserInvite,
     UserRole,
     UserSkill,
     UserTask
@@ -191,6 +192,9 @@ defmodule CodeCorps.Policy do
   defp can?(%User{} = current_user, :create, %UserCategory{}, %{} = params), do: Policy.UserCategory.create?(current_user, params)
   defp can?(%User{} = current_user, :delete, %UserCategory{} = user_category, %{}), do: Policy.UserCategory.delete?(current_user, user_category)
 
+  # UserInvite
+  defp can?(%User{} = current_user, :create, %UserInvite{}, %{} = params), do: Policy.UserInvite.create?(current_user, params)
+
   # UserRole
   defp can?(%User{} = current_user, :create, %UserRole{}, %{} = params), do: Policy.UserRole.create?(current_user, params)
   defp can?(%User{} = current_user, :delete, %UserRole{} = user_role, %{}), do: Policy.UserRole.delete?(current_user, user_role)

lib/code_corps/policy/user_invite.ex

@@ -0,0 +1,42 @@
+defmodule CodeCorps.Policy.UserInvite do
+  @moduledoc ~S"""
+  Handles `CodeCorps.User` authorization of actions on `CodeCorps.UserInvite`
+  records.
+  """
+
+  alias CodeCorps.{Policy.Helpers, User}
+
+  @doc ~S"""
+  Returns true if the specified `CodeCorps.User` is allowed to create a
+  `CodeCorps.UserInvite` using the specified attributes.
+  """
+  @spec create?(User.t(), map) :: boolean
+  def create?(
+        %User{id: user_id} = user,
+        %{"project_id" => _, "inviter_id" => inviter_id} = params
+      )
+      when user_id == inviter_id do
+    user_role =
+      params
+      |> Helpers.get_project()
+      |> Helpers.get_membership(user)
+      |> Helpers.get_role()
+
+    new_role = Map.get(params, "role")
+    do_create?(user_role, new_role)
+  end
+
+  def create?(%User{id: user_id}, %{"inviter_id" => inviter_id})
+      when user_id == inviter_id,
+      do: true
+
+  def create?(%User{}, %{}), do: false
+
+  @spec do_create?(String.t() | nil, String.t() | nil) :: boolean
+  defp do_create?("admin", "pending"), do: true
+  defp do_create?("admin", "contributor"), do: true
+  defp do_create?("owner", "pending"), do: true
+  defp do_create?("owner", "contributor"), do: true
+  defp do_create?("owner", "admin"), do: true
+  defp do_create?(_, _), do: false
+end

lib/code_corps/validators/slug_validator.ex

@@ -50,8 +50,8 @@ defmodule CodeCorps.Validators.SlugValidator do
       stripe-platform-customers
       tags tasks task-images task-likes task-lists task-skills
       teams token tokens
-      user-categories user-roles user-skills user-tasks user username_available
-      users
+      user-categories user-invites user-roles user-skills user-tasks user
+      username_available users
       webhooks
     )