Integrate URLS to Video Conference Rooms

- A new `TeamVideoConferenceRoom` schema for session-specific remote
  rooms, associated with events.

- Updated `DevRound.Events.Event` to store a
  `main_video_conference_room_url` and manage
  `team_video_conference_rooms`.

- Added URL validation logic to `DevRound.Changeset` ensuring only valid
  HTTP(S) URLs are used for conference links.

- Refactored `DevRound.Hosting` team generation algorithms to accept
  video conference room URLs and assign them to remote teams, including
  validation for sufficient availability.

- Update the event admin view for video conference URL entry.

- Updated templates to display conference room links for users.

Author: sebasgo

lib/dev_round/changeset.ex

@@ -157,4 +157,31 @@ defmodule DevRound.Changeset do
         end
     end
   end
+
+  @doc """
+  Validates that given field contains a valid HTTP or HTTPS URL.
+
+  ## Examples
+
+      iex> changeset = %Ecto.Changeset{changes: %{url: "http://example.com"}}
+      iex> Changeset.validate_http_url(changeset, :url)
+      # No error added
+
+      iex> changeset = %Ecto.Changeset{changes: %{url: "invalid"}}
+      iex> Changeset.validate_http_url(changeset, :url)
+      # Adds error to url field
+
+  """
+  def validate_http_url(changeset, field) do
+    validate_change(changeset, field, fn field, url ->
+      case URI.parse(url) do
+        %URI{scheme: scheme, host: host}
+        when scheme in ["http", "https"] and not is_nil(host) and host != "" ->
+          []
+
+        _ ->
+          [{field, "Must be a valid HTTP(S) URL."}]
+      end
+    end)
+  end
 end

lib/dev_round/events.ex

@@ -105,7 +105,13 @@ defmodule DevRound.Events do
     sessions_query = from s in EventSession, order_by: s.begin
 
     event
-    |> Repo.preload([:langs, :hosts, :last_live_session, sessions: sessions_query])
+    |> Repo.preload([
+      :langs,
+      :hosts,
+      :last_live_session,
+      :team_video_conference_rooms,
+      sessions: sessions_query
+    ])
     |> Repo.preload(events_attendees: {attendee_query, [:user, :langs]})
   end
 

lib/dev_round/events/event.ex

@@ -31,9 +31,14 @@ defmodule DevRound.Events.Event do
     field :slides_page_number, :integer
     field :live, :boolean
     field :modified_at, :utc_datetime
+    field :main_video_conference_room_url, :string
 
     many_to_many :langs, Lang, join_through: "event_langs", on_replace: :delete
 
+    has_many :team_video_conference_rooms, DevRound.Events.TeamVideoConferenceRoom,
+      on_replace: :delete,
+      on_delete: :delete_all
+
     has_many :event_hosts, EventHost,
       preload_order: [asc: :position],
       on_replace: :delete,
@@ -60,7 +65,8 @@ defmodule DevRound.Events.Event do
       :location,
       :published,
       :registration_deadline_local,
-      :slides_filename
+      :slides_filename,
+      :main_video_conference_room_url
     ])
     |> cast_assoc(:event_hosts,
       with: &EventHost.changeset/3,
@@ -76,6 +82,11 @@ defmodule DevRound.Events.Event do
       sort_param: :sessions_order,
       drop_param: :sessions_delete
     )
+    |> cast_assoc(:team_video_conference_rooms,
+      with: &DevRound.Events.TeamVideoConferenceRoom.changeset/2,
+      sort_param: :team_video_conference_rooms_order,
+      drop_param: :team_video_conference_rooms_delete
+    )
     |> put_langs_assoc(Keyword.get(opts, :put_langs))
     |> validate_required(
       [
@@ -107,6 +118,7 @@ defmodule DevRound.Events.Event do
         _ -> []
       end
     end)
+    |> validate_http_url(:main_video_conference_room_url)
     |> unique_constraint(:slug)
     |> change(modified_at: DateTime.utc_now(:second))
   end

lib/dev_round/events/team_video_conference_room.ex

@@ -0,0 +1,18 @@
+defmodule DevRound.Events.TeamVideoConferenceRoom do
+  use Ecto.Schema
+  import Ecto.Changeset
+  import DevRound.Changeset
+  alias DevRound.Events.Event
+
+  schema "team_video_conference_rooms" do
+    field :url, :string
+    belongs_to :event, Event
+  end
+
+  def changeset(room, attrs) do
+    room
+    |> cast(attrs, [:url])
+    |> validate_required([:url])
+    |> validate_http_url(:url)
+  end
+end

lib/dev_round/hosting.ex

@@ -124,11 +124,11 @@ defmodule DevRound.Hosting do
     EventAttendee.check_changeset(attendee, %{checked: checked})
   end
 
-  def validate_team_generation_constraints(attendees, team_names) do
+  def validate_team_generation_constraints(attendees, team_names, team_rooms) do
     attendees = filter_checked(attendees)
 
     if Enum.count(attendees) >= 2 do
-      messages = build_validation_messages(attendees, team_names)
+      messages = build_validation_messages(attendees, team_names, team_rooms)
 
       case messages do
         [] -> {:ok, []}
@@ -139,7 +139,7 @@ defmodule DevRound.Hosting do
     end
   end
 
-  defp build_validation_messages(attendees, team_names) do
+  defp build_validation_messages(attendees, team_names, team_rooms) do
     attendee_messages =
       for attendee <- attendees do
         potential_team_mates =
@@ -162,7 +162,18 @@ defmodule DevRound.Hosting do
         []
       end
 
-    attendee_messages ++ team_names_message
+    remote_attendees = Enum.filter(attendees, & &1.is_remote)
+
+    video_conference_rooms_message =
+      if Integer.floor_div(length(remote_attendees), 2) > length(team_rooms) do
+        [
+          "Not enough session video conference room URLs to build teams for checked remote participants."
+        ]
+      else
+        []
+      end
+
+    attendee_messages ++ team_names_message ++ video_conference_rooms_message
   end
 
   defp filter_checked(attendees) do
@@ -197,29 +208,32 @@ defmodule DevRound.Hosting do
     |> Enum.into(%{}, fn team -> {team.session_id, team} end)
   end
 
-  def build_teams_for_session(%EventSession{} = session, attendees, team_names) do
+  def build_teams_for_session(%EventSession{} = session, attendees, team_names, team_rooms) do
     attendees = filter_checked(attendees)
-    {:ok, []} = validate_team_generation_constraints(attendees, team_names)
+    {:ok, []} = validate_team_generation_constraints(attendees, team_names, team_rooms)
 
     Multi.new()
     |> Multi.delete_all(:teams, Ecto.assoc(session, :teams))
-    |> insert_teams(session, attendees, team_names)
+    |> insert_teams(session, attendees, team_names, team_rooms)
     |> Repo.transaction()
   end
 
-  defp insert_teams(multi, session, attendees, team_names) do
-    generate_team_changesets(session, attendees, team_names)
+  defp insert_teams(multi, session, attendees, team_names, team_rooms) do
+    generate_team_changesets(session, attendees, team_names, team_rooms)
     |> Enum.reduce(multi, &Multi.insert(&2, Changeset.get_change(&1, :slug), &1))
   end
 
-  defp generate_team_changesets(session, attendees, team_names) do
+  defp generate_team_changesets(session, attendees, team_names, team_rooms) do
     {local_teams, local_langs} = generate_teams_langs(attendees, false)
     {remote_teams, remote_langs} = generate_teams_langs(attendees, true)
 
+    room_urls = team_rooms |> Enum.map(& &1.url)
+
     create_team_changesets(
       {local_teams ++ remote_teams, local_langs ++ remote_langs},
       session,
-      team_names
+      team_names,
+      room_urls
     )
   end
 
@@ -293,34 +307,48 @@ defmodule DevRound.Hosting do
     MapSet.new()
   end
 
-  defp create_team_changesets({teams_attendees, teams_langs}, session, team_names) do
+  defp create_team_changesets({teams_attendees, teams_langs}, session, team_names, room_urls) do
     names = team_names |> Enum.shuffle() |> Enum.take(length(teams_attendees))
 
-    Enum.zip([teams_attendees, teams_langs, names])
-    |> Enum.map(fn {team_attendees, team_langs, name} ->
-      lang = Enum.random(team_langs)
-      is_remote = hd(team_attendees).is_remote
+    {changesets, _remaining_urls} =
+      Enum.zip([teams_attendees, teams_langs, names])
+      |> Enum.map_reduce(room_urls, fn {team_attendees, team_langs, name}, available_urls ->
+        lang = Enum.random(team_langs)
+        is_remote = hd(team_attendees).is_remote
+
+        {room_url, next_urls} =
+          if is_remote && available_urls != [] do
+            {hd(available_urls), tl(available_urls)}
+          else
+            {nil, available_urls}
+          end
+
+        members =
+          Enum.map(team_attendees, fn attendee ->
+            %TeamMember{}
+            |> Changeset.change(
+              is_remote: attendee.is_remote,
+              experience_level: attendee.experience_level,
+              user: attendee.user
+            )
+            |> Changeset.put_assoc(:langs, attendee.langs)
+          end)
 
-      members =
-        Enum.map(team_attendees, fn attendee ->
-          %TeamMember{}
+        changeset =
+          %Team{}
           |> Changeset.change(
-            is_remote: attendee.is_remote,
-            experience_level: attendee.experience_level,
-            user: attendee.user
+            name: name.name,
+            slug: name.slug,
+            is_remote: is_remote,
+            session: session,
+            lang: lang,
+            video_conference_room_url: room_url
           )
-          |> Changeset.put_assoc(:langs, attendee.langs)
-        end)
-
-      %Team{}
-      |> Changeset.change(
-        name: name.name,
-        slug: name.slug,
-        is_remote: is_remote,
-        session: session,
-        lang: lang
-      )
-      |> Changeset.put_assoc(:members, members)
-    end)
+          |> Changeset.put_assoc(:members, members)
+
+        {changeset, next_urls}
+      end)
+
+    changesets
   end
 end

lib/dev_round/hosting/team.ex

@@ -17,6 +17,7 @@ defmodule DevRound.Hosting.Team do
     field :name, :string
     field :slug, :string
     field :is_remote, :boolean, default: false
+    field :video_conference_room_url, :string
 
     belongs_to :session, EventSession
     belongs_to :lang, Lang
@@ -28,7 +29,7 @@ defmodule DevRound.Hosting.Team do
   @doc false
   def changeset(team, attrs) do
     team
-    |> cast(attrs, [:name, :slug, :is_remote])
+    |> cast(attrs, [:name, :slug, :is_remote, :video_conference_room_url])
     |> validate_required([:name, :slug, :is_remote])
   end
 end