524 lines
15 KiB
Elixir
524 lines
15 KiB
Elixir
|
defmodule Rsh26pool.Voting do
|
||
|
|
@moduledoc """
|
||
|
|
The Voting context: rooms, participants, ideas/opinions, votes, results and
|
||
|
|
(in grouping mode) team assignment via the Hungarian algorithm.
|
||
|
|
|
||
|
|
Timestamps are stored in UTC. Real-time updates are published over
|
||
|
|
`Phoenix.PubSub`; interested LiveViews call `subscribe/1` and handle
|
||
|
|
`{:voting, event}` messages.
|
||
|
|
"""
|
||
|
|
|
||
|
|
import Ecto.Query, warn: false
|
||
|
|
|
||
|
|
alias Rsh26pool.Repo
|
||
|
|
alias Rsh26pool.Voting.{Hungarian, Idea, Participant, Room, Vote}
|
||
|
|
|
||
|
|
@pubsub Rsh26pool.PubSub
|
||
|
|
|
||
|
|
## Real-time -------------------------------------------------------------
|
||
|
|
|
||
|
|
@doc "Subscribe the calling process to a room's update stream."
|
||
|
|
def subscribe(room_id) do
|
||
|
|
Phoenix.PubSub.subscribe(@pubsub, topic(room_id))
|
||
|
|
end
|
||
|
|
|
||
|
|
defp broadcast(room_id, event) do
|
||
|
|
Phoenix.PubSub.broadcast(@pubsub, topic(room_id), {:voting, event})
|
||
|
|
end
|
||
|
|
|
||
|
|
defp topic(room_id), do: "room:#{room_id}"
|
||
|
|
|
||
|
|
## Rooms ----------------------------------------------------------------
|
||
|
|
|
||
|
|
@doc "Builds a creation changeset for the room settings form."
|
||
|
|
def change_room_creation(%Room{} = room \\ %Room{}, attrs \\ %{}) do
|
||
|
|
Room.create_changeset(room, attrs)
|
||
|
|
end
|
||
|
|
|
||
|
|
@doc "Builds a settings changeset for the manage page rename form."
|
||
|
|
def change_room_settings(%Room{} = room, attrs \\ %{}) do
|
||
|
|
Room.settings_changeset(room, attrs)
|
||
|
|
end
|
||
|
|
|
||
|
|
@doc """
|
||
|
|
Creates a room from the settings form and its owner participant.
|
||
|
|
|
||
|
|
Returns `{:ok, %{room: room, owner: owner}}` or `{:error, changeset}`.
|
||
|
|
"""
|
||
|
|
def create_room(attrs) do
|
||
|
|
changeset = Room.create_changeset(%Room{}, attrs)
|
||
|
|
|
||
|
|
if changeset.valid? do
|
||
|
|
changeset = Ecto.Changeset.put_change(changeset, :room_number, unique_room_number())
|
||
|
|
|
||
|
|
Repo.transaction(fn ->
|
||
|
|
room = Repo.insert!(changeset)
|
||
|
|
|
||
|
|
owner =
|
||
|
|
Repo.insert!(%Participant{
|
||
|
|
room_id: room.id,
|
||
|
|
role: "owner",
|
||
|
|
name: "オーナー",
|
||
|
|
token: generate_token()
|
||
|
|
})
|
||
|
|
|
||
|
|
%{room: room, owner: owner}
|
||
|
|
end)
|
||
|
|
else
|
||
|
|
{:error, %{changeset | action: :insert}}
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
def get_room_by_number(number) when is_binary(number) do
|
||
|
|
Repo.get_by(Room, room_number: number)
|
||
|
|
end
|
||
|
|
|
||
|
|
def get_room_by_number(_), do: nil
|
||
|
|
|
||
|
|
def get_room!(id), do: Repo.get!(Room, id)
|
||
|
|
|
||
|
|
def reload_room(%Room{id: id}), do: Repo.get(Room, id)
|
||
|
|
|
||
|
|
@doc "Updates owner-editable settings (currently the room name)."
|
||
|
|
def update_room_settings(%Room{} = room, attrs) do
|
||
|
|
room
|
||
|
|
|> Room.settings_changeset(attrs)
|
||
|
|
|> Repo.update()
|
||
|
|
|> case do
|
||
|
|
{:ok, room} = ok ->
|
||
|
|
broadcast(room.id, :room_updated)
|
||
|
|
ok
|
||
|
|
|
||
|
|
other ->
|
||
|
|
other
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
@doc """
|
||
|
|
The status a room should be treated as *right now*, accounting for a passed
|
||
|
|
`closes_at` deadline even if the background closer has not run yet.
|
||
|
|
"""
|
||
|
|
def effective_status(%Room{status: "closed"}), do: "closed"
|
||
|
|
def effective_status(%Room{closes_at: nil}), do: "open"
|
||
|
|
|
||
|
|
def effective_status(%Room{closes_at: closes_at}) do
|
||
|
|
if DateTime.compare(closes_at, DateTime.utc_now()) != :gt, do: "closed", else: "open"
|
||
|
|
end
|
||
|
|
|
||
|
|
def room_open?(%Room{} = room), do: effective_status(room) == "open"
|
||
|
|
|
||
|
|
@doc """
|
||
|
|
Closes a room: marks it closed and, in grouping mode, computes the team
|
||
|
|
assignments (idempotent — safe to call more than once).
|
||
|
|
"""
|
||
|
|
def close_room(%Room{} = room) do
|
||
|
|
room = Repo.get!(Room, room.id)
|
||
|
|
|
||
|
|
if room.status == "closed" do
|
||
|
|
{:ok, room}
|
||
|
|
else
|
||
|
|
{:ok, closed} =
|
||
|
|
room
|
||
|
|
|> Ecto.Changeset.change(status: "closed")
|
||
|
|
|> Repo.update()
|
||
|
|
|
||
|
|
closed = if closed.grouping_mode, do: compute_grouping(closed), else: closed
|
||
|
|
broadcast(closed.id, :room_updated)
|
||
|
|
{:ok, closed}
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
@doc """
|
||
|
|
Ensures a room past its deadline is actually closed. Returns the (possibly
|
||
|
|
updated) room. Used lazily by pages so viewers never see a stale open room.
|
||
|
|
"""
|
||
|
|
def ensure_closed(%Room{} = room) do
|
||
|
|
if room.status == "open" and effective_status(room) == "closed" do
|
||
|
|
{:ok, closed} = close_room(room)
|
||
|
|
closed
|
||
|
|
else
|
||
|
|
room
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
@doc "Lists rooms that are open but past their auto-close deadline."
|
||
|
|
def list_rooms_to_auto_close do
|
||
|
|
now = DateTime.utc_now()
|
||
|
|
|
||
|
|
Repo.all(
|
||
|
|
from r in Room,
|
||
|
|
where: r.status == "open" and not is_nil(r.closes_at) and r.closes_at <= ^now
|
||
|
|
)
|
||
|
|
end
|
||
|
|
|
||
|
|
## Participants ---------------------------------------------------------
|
||
|
|
|
||
|
|
@doc "Changeset for the join form."
|
||
|
|
def change_participant(%Participant{} = participant \\ %Participant{}, attrs \\ %{}) do
|
||
|
|
Participant.changeset(participant, attrs)
|
||
|
|
end
|
||
|
|
|
||
|
|
@doc """
|
||
|
|
Joins a room as a member, generating an auth token.
|
||
|
|
|
||
|
|
Returns `{:ok, participant}` or `{:error, changeset}`.
|
||
|
|
"""
|
||
|
|
def join_room(%Room{} = room, attrs) do
|
||
|
|
%Participant{room_id: room.id, role: "member", token: generate_token()}
|
||
|
|
|> Participant.changeset(attrs)
|
||
|
|
|> Repo.insert()
|
||
|
|
end
|
||
|
|
|
||
|
|
def get_participant_by_token(nil), do: nil
|
||
|
|
|
||
|
|
def get_participant_by_token(token) when is_binary(token) do
|
||
|
|
Repo.one(from p in Participant, where: p.token == ^token, preload: [:room])
|
||
|
|
end
|
||
|
|
|
||
|
|
def list_participants(%Room{} = room) do
|
||
|
|
Repo.all(from p in Participant, where: p.room_id == ^room.id, order_by: [asc: p.id])
|
||
|
|
end
|
||
|
|
|
||
|
|
def count_participants(%Room{} = room) do
|
||
|
|
Repo.aggregate(from(p in Participant, where: p.room_id == ^room.id), :count)
|
||
|
|
end
|
||
|
|
|
||
|
|
## Ideas ----------------------------------------------------------------
|
||
|
|
|
||
|
|
def change_idea(%Idea{} = idea \\ %Idea{}, attrs \\ %{}) do
|
||
|
|
Idea.changeset(idea, attrs)
|
||
|
|
end
|
||
|
|
|
||
|
|
@doc """
|
||
|
|
Posts an idea/opinion. In grouping mode each participant has a single opinion,
|
||
|
|
so an existing one is updated instead of inserting a second.
|
||
|
|
"""
|
||
|
|
def create_idea(%Room{} = room, %Participant{} = participant, attrs) do
|
||
|
|
cond do
|
||
|
|
not room_open?(room) ->
|
||
|
|
{:error, :closed}
|
||
|
|
|
||
|
|
room.grouping_mode ->
|
||
|
|
case get_participant_idea(room, participant) do
|
||
|
|
nil -> do_insert_idea(room, participant, attrs)
|
||
|
|
existing -> do_update_idea(room, existing, attrs)
|
||
|
|
end
|
||
|
|
|
||
|
|
true ->
|
||
|
|
do_insert_idea(room, participant, attrs)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
defp do_insert_idea(room, participant, attrs) do
|
||
|
|
%Idea{room_id: room.id, participant_id: participant.id}
|
||
|
|
|> Idea.changeset(attrs)
|
||
|
|
|> Repo.insert()
|
||
|
|
|> tap_broadcast(room, :ideas_changed)
|
||
|
|
end
|
||
|
|
|
||
|
|
defp do_update_idea(room, idea, attrs) do
|
||
|
|
idea
|
||
|
|
|> Idea.changeset(attrs)
|
||
|
|
|> Repo.update()
|
||
|
|
|> tap_broadcast(room, :ideas_changed)
|
||
|
|
end
|
||
|
|
|
||
|
|
def get_participant_idea(%Room{} = room, %Participant{} = participant) do
|
||
|
|
Repo.one(
|
||
|
|
from i in Idea,
|
||
|
|
where: i.room_id == ^room.id and i.participant_id == ^participant.id,
|
||
|
|
order_by: [asc: i.id],
|
||
|
|
limit: 1
|
||
|
|
)
|
||
|
|
end
|
||
|
|
|
||
|
|
def list_ideas(%Room{} = room) do
|
||
|
|
Repo.all(
|
||
|
|
from i in Idea,
|
||
|
|
where: i.room_id == ^room.id,
|
||
|
|
order_by: [asc: i.id],
|
||
|
|
preload: [:participant]
|
||
|
|
)
|
||
|
|
end
|
||
|
|
|
||
|
|
@doc """
|
||
|
|
Ideas ordered by a per-viewer deterministic shuffle. Order is stable for a
|
||
|
|
given `seed` (so it does not jump around on live updates) but differs between
|
||
|
|
viewers, satisfying the "shuffled choices" requirement.
|
||
|
|
"""
|
||
|
|
def shuffled_ideas(%Room{} = room, seed) do
|
||
|
|
room
|
||
|
|
|> list_ideas()
|
||
|
|
|> Enum.sort_by(fn idea -> :erlang.phash2({seed, idea.id}) end)
|
||
|
|
end
|
||
|
|
|
||
|
|
## Votes ----------------------------------------------------------------
|
||
|
|
|
||
|
|
@doc """
|
||
|
|
Casts a vote for `idea_id` by `participant`, enforcing the room's per-user
|
||
|
|
vote limit, one-vote-per-idea, and that the room is still open.
|
||
|
|
"""
|
||
|
|
def vote(%Participant{} = participant, idea_id) do
|
||
|
|
room = Repo.get!(Room, participant.room_id)
|
||
|
|
idea = Repo.get_by(Idea, id: idea_id, room_id: room.id)
|
||
|
|
|
||
|
|
cond do
|
||
|
|
not room_open?(room) -> {:error, :closed}
|
||
|
|
is_nil(idea) -> {:error, :not_found}
|
||
|
|
voted?(participant, idea.id) -> {:error, :already_voted}
|
||
|
|
votes_used(participant) >= room.votes_per_user -> {:error, :limit_reached}
|
||
|
|
true -> insert_vote(room, participant, idea)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
defp insert_vote(room, participant, idea) do
|
||
|
|
%Vote{}
|
||
|
|
|> Vote.changeset(%{idea_id: idea.id, participant_id: participant.id})
|
||
|
|
|> Repo.insert()
|
||
|
|
|> case do
|
||
|
|
{:ok, vote} ->
|
||
|
|
broadcast(room.id, :votes_changed)
|
||
|
|
{:ok, vote}
|
||
|
|
|
||
|
|
{:error, changeset} ->
|
||
|
|
{:error, changeset}
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
@doc "Removes a participant's vote for an idea, if the room is still open."
|
||
|
|
def unvote(%Participant{} = participant, idea_id) do
|
||
|
|
room = Repo.get!(Room, participant.room_id)
|
||
|
|
|
||
|
|
cond do
|
||
|
|
not room_open?(room) ->
|
||
|
|
{:error, :closed}
|
||
|
|
|
||
|
|
true ->
|
||
|
|
case Repo.get_by(Vote, idea_id: idea_id, participant_id: participant.id) do
|
||
|
|
nil ->
|
||
|
|
{:error, :not_found}
|
||
|
|
|
||
|
|
vote ->
|
||
|
|
{:ok, _} = Repo.delete(vote)
|
||
|
|
broadcast(room.id, :votes_changed)
|
||
|
|
:ok
|
||
|
|
end
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
def voted?(%Participant{} = participant, idea_id) do
|
||
|
|
Repo.exists?(
|
||
|
|
from v in Vote, where: v.participant_id == ^participant.id and v.idea_id == ^idea_id
|
||
|
|
)
|
||
|
|
end
|
||
|
|
|
||
|
|
def votes_used(%Participant{} = participant) do
|
||
|
|
Repo.aggregate(from(v in Vote, where: v.participant_id == ^participant.id), :count)
|
||
|
|
end
|
||
|
|
|
||
|
|
def votes_remaining(%Room{} = room, %Participant{} = participant) do
|
||
|
|
max(room.votes_per_user - votes_used(participant), 0)
|
||
|
|
end
|
||
|
|
|
||
|
|
@doc "Set of idea ids the participant has voted for (for UI highlighting)."
|
||
|
|
def voted_idea_ids(%Participant{} = participant) do
|
||
|
|
Repo.all(from v in Vote, where: v.participant_id == ^participant.id, select: v.idea_id)
|
||
|
|
|> MapSet.new()
|
||
|
|
end
|
||
|
|
|
||
|
|
## Results --------------------------------------------------------------
|
||
|
|
|
||
|
|
@doc "Map of `idea_id => vote_count` for a room."
|
||
|
|
def vote_counts(%Room{} = room) do
|
||
|
|
Repo.all(
|
||
|
|
from v in Vote,
|
||
|
|
join: i in Idea,
|
||
|
|
on: i.id == v.idea_id,
|
||
|
|
where: i.room_id == ^room.id,
|
||
|
|
group_by: v.idea_id,
|
||
|
|
select: {v.idea_id, count(v.id)}
|
||
|
|
)
|
||
|
|
|> Map.new()
|
||
|
|
end
|
||
|
|
|
||
|
|
@doc "Ideas with their vote counts, highest first (for the manage page)."
|
||
|
|
def results(%Room{} = room) do
|
||
|
|
counts = vote_counts(room)
|
||
|
|
|
||
|
|
room
|
||
|
|
|> list_ideas()
|
||
|
|
|> Enum.map(fn idea -> %{idea: idea, count: Map.get(counts, idea.id, 0)} end)
|
||
|
|
|> Enum.sort_by(& &1.count, :desc)
|
||
|
|
end
|
||
|
|
|
||
|
|
## Grouping mode --------------------------------------------------------
|
||
|
|
|
||
|
|
@doc """
|
||
|
|
Returns the computed grouping as `%{groups: [...], ungrouped: [...]}` where
|
||
|
|
each group is `%{leader: participant, opinion: idea, members: [participant]}`.
|
||
|
|
Only meaningful after a grouping-mode room has been closed.
|
||
|
|
"""
|
||
|
|
def group_assignments(%Room{} = room) do
|
||
|
|
members = room |> list_participants() |> Enum.filter(&(&1.role == "member"))
|
||
|
|
counts = vote_counts(room)
|
||
|
|
idea_by_participant = idea_by_participant(room)
|
||
|
|
|
||
|
|
leaders =
|
||
|
|
members
|
||
|
|
|> Enum.filter(& &1.is_leader)
|
||
|
|
|> Enum.sort_by(&(-opinion_votes(&1, idea_by_participant, counts)))
|
||
|
|
|
||
|
|
groups =
|
||
|
|
Enum.map(leaders, fn leader ->
|
||
|
|
group_members =
|
||
|
|
Enum.filter(members, fn p ->
|
||
|
|
not p.is_leader and p.assigned_leader_id == leader.id
|
||
|
|
end)
|
||
|
|
|
||
|
|
%{
|
||
|
|
leader: leader,
|
||
|
|
opinion: Map.get(idea_by_participant, leader.id),
|
||
|
|
members: group_members
|
||
|
|
}
|
||
|
|
end)
|
||
|
|
|
||
|
|
ungrouped =
|
||
|
|
Enum.filter(members, fn p -> not p.is_leader and is_nil(p.assigned_leader_id) end)
|
||
|
|
|
||
|
|
%{groups: groups, ungrouped: ungrouped}
|
||
|
|
end
|
||
|
|
|
||
|
|
defp compute_grouping(room) do
|
||
|
|
members = room |> list_participants() |> Enum.filter(&(&1.role == "member"))
|
||
|
|
counts = vote_counts(room)
|
||
|
|
idea_by_participant = idea_by_participant(room)
|
||
|
|
|
||
|
|
leaders =
|
||
|
|
Enum.filter(members, fn p ->
|
||
|
|
Map.has_key?(idea_by_participant, p.id) and
|
||
|
|
opinion_votes(p, idea_by_participant, counts) >= room.leader_threshold
|
||
|
|
end)
|
||
|
|
|
||
|
|
regular = members -- leaders
|
||
|
|
|
||
|
|
Repo.transaction(fn ->
|
||
|
|
if leaders == [] do
|
||
|
|
Enum.each(members, &set_group(&1, false, nil))
|
||
|
|
else
|
||
|
|
Enum.each(leaders, &set_group(&1, true, &1.id))
|
||
|
|
|
||
|
|
regular
|
||
|
|
|> assign_regular_members(leaders, room, idea_by_participant)
|
||
|
|
|> Enum.each(fn {member, leader_id} -> set_group(member, false, leader_id) end)
|
||
|
|
end
|
||
|
|
|
||
|
|
now = DateTime.utc_now() |> DateTime.truncate(:second)
|
||
|
|
Repo.update!(Ecto.Changeset.change(room, grouped_at: now))
|
||
|
|
end)
|
||
|
|
|> case do
|
||
|
|
{:ok, updated_room} -> updated_room
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
# Assigns non-leader members to leader groups minimising unmet preferences via
|
||
|
|
# the Hungarian algorithm. Returns `[{member, leader_id}]`.
|
||
|
|
defp assign_regular_members([], _leaders, _room, _idea_by_participant), do: []
|
||
|
|
|
||
|
|
defp assign_regular_members(regular, leaders, room, idea_by_participant) do
|
||
|
|
m = length(regular)
|
||
|
|
l = length(leaders)
|
||
|
|
base = div(m, l)
|
||
|
|
remainder = rem(m, l)
|
||
|
|
|
||
|
|
# Balanced capacity per leader; expanded into one slot per capacity unit.
|
||
|
|
caps = Enum.map(0..(l - 1), fn i -> base + if(i < remainder, do: 1, else: 0) end)
|
||
|
|
|
||
|
|
slot_leaders =
|
||
|
|
Enum.flat_map(Enum.zip(leaders, caps), fn {leader, cap} ->
|
||
|
|
List.duplicate(leader, cap)
|
||
|
|
end)
|
||
|
|
|
||
|
|
voted_by = votes_by_participant(room)
|
||
|
|
|
||
|
|
cost =
|
||
|
|
Enum.map(regular, fn member ->
|
||
|
|
voted = Map.get(voted_by, member.id, MapSet.new())
|
||
|
|
|
||
|
|
Enum.map(slot_leaders, fn leader ->
|
||
|
|
opinion = Map.get(idea_by_participant, leader.id)
|
||
|
|
|
||
|
|
if opinion && MapSet.member?(voted, opinion.id), do: 0, else: 1
|
||
|
|
end)
|
||
|
|
end)
|
||
|
|
|
||
|
|
{_total, assignment} = Hungarian.min_cost_assignment(cost)
|
||
|
|
|
||
|
|
regular
|
||
|
|
|> Enum.zip(assignment)
|
||
|
|
|> Enum.map(fn {member, slot_index} ->
|
||
|
|
leader = Enum.at(slot_leaders, slot_index)
|
||
|
|
{member, leader.id}
|
||
|
|
end)
|
||
|
|
end
|
||
|
|
|
||
|
|
defp set_group(participant, is_leader, leader_id) do
|
||
|
|
participant
|
||
|
|
|> Ecto.Changeset.change(is_leader: is_leader, assigned_leader_id: leader_id)
|
||
|
|
|> Repo.update!()
|
||
|
|
end
|
||
|
|
|
||
|
|
defp idea_by_participant(room) do
|
||
|
|
room
|
||
|
|
|> list_ideas()
|
||
|
|
|> Map.new(fn idea -> {idea.participant_id, idea} end)
|
||
|
|
end
|
||
|
|
|
||
|
|
defp opinion_votes(participant, idea_by_participant, counts) do
|
||
|
|
case Map.get(idea_by_participant, participant.id) do
|
||
|
|
nil -> 0
|
||
|
|
idea -> Map.get(counts, idea.id, 0)
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
defp votes_by_participant(room) do
|
||
|
|
Repo.all(
|
||
|
|
from v in Vote,
|
||
|
|
join: i in Idea,
|
||
|
|
on: i.id == v.idea_id,
|
||
|
|
where: i.room_id == ^room.id,
|
||
|
|
select: {v.participant_id, v.idea_id}
|
||
|
|
)
|
||
|
|
|> Enum.group_by(&elem(&1, 0), &elem(&1, 1))
|
||
|
|
|> Map.new(fn {participant_id, idea_ids} -> {participant_id, MapSet.new(idea_ids)} end)
|
||
|
|
end
|
||
|
|
|
||
|
|
## Helpers --------------------------------------------------------------
|
||
|
|
|
||
|
|
defp generate_token do
|
||
|
|
:crypto.strong_rand_bytes(24) |> Base.url_encode64(padding: false)
|
||
|
|
end
|
||
|
|
|
||
|
|
defp unique_room_number(attempts \\ 0)
|
||
|
|
|
||
|
|
defp unique_room_number(attempts) when attempts < 20 do
|
||
|
|
number = Integer.to_string(:rand.uniform(900_000) + 99_999)
|
||
|
|
|
||
|
|
if Repo.exists?(from r in Room, where: r.room_number == ^number) do
|
||
|
|
unique_room_number(attempts + 1)
|
||
|
|
else
|
||
|
|
number
|
||
|
|
end
|
||
|
|
end
|
||
|
|
|
||
|
|
defp unique_room_number(_attempts) do
|
||
|
|
raise "could not allocate a unique room number"
|
||
|
|
end
|
||
|
|
|
||
|
|
defp tap_broadcast({:ok, _} = result, room, event) do
|
||
|
|
broadcast(room.id, event)
|
||
|
|
result
|
||
|
|
end
|
||
|
|
|
||
|
|
defp tap_broadcast(other, _room, _event), do: other
|
||
|
|
end
|