wip: feat: Define show screen for transcriptions

lib/medical_transcription/transcription.ex

@@ -1,9 +0,0 @@
-defmodule MedicalTranscription.Transcription do
-  @moduledoc """
-  Takes a path to an audio file and transcribes it to text.
-  """
-
-  def stream_transcription_and_search(audio_file_path) do
-    MedicalTranscription.TranscriptionSupervisor.start_transcription(audio_file_path)
-  end
-end

lib/medical_transcription/transcription_server.ex

@@ -20,8 +20,8 @@ defmodule MedicalTranscription.TranscriptionServer do
   end
 
   @impl GenServer
-  def handle_continue(:start, [file_path: file_path] = state) do
-    stream_transcription_and_search(file_path)
+  def handle_continue(:start, [transcription: transcription] = state) do
+    stream_transcription_and_search(transcription.filename)
     {:noreply, state}
   end
 

lib/medical_transcription/transcription_supervisor.ex

@@ -11,8 +11,8 @@ defmodule MedicalTranscription.TranscriptionSupervisor do
     DynamicSupervisor.init(strategy: :one_for_one)
   end
 
-  def start_transcription(uploaded_file) do
-    spec = {MedicalTranscription.TranscriptionServer, file_path: uploaded_file}
+  def start_transcription(transcription) do
+    spec = {MedicalTranscription.TranscriptionServer, transcription: transcription}
     DynamicSupervisor.start_child(__MODULE__, spec)
   end
 end

lib/medical_transcription/transcriptions.ex

@@ -8,6 +8,18 @@ defmodule MedicalTranscription.Transcriptions do
 
   alias MedicalTranscription.Transcriptions.Transcription
 
+  @doc """
+  Create transcription record and begin transcribing
+
+  ## Examples
+
+      iex> create_and_transcribe_audio("my-audio.mp3")
+      %Transcription{audio_file: "my-audio.mp3"}
+  """
+  def transcribe_audio(transcription) do
+    MedicalTranscription.TranscriptionSupervisor.start_transcription(transcription)
+  end
+
   @doc """
   Returns the list of transcriptions.
 

lib/medical_transcription_web/live/home_live/index.ex

@@ -85,19 +85,24 @@ defmodule MedicalTranscriptionWeb.HomeLive.Index do
         {:ok, dest}
       end)
 
-    uploaded_files
-    |> Enum.at(0)
-    |> transcribe_and_tag_audio()
-
-    socket =
-      socket
-      |> assign(:status, :loading)
-      |> assign(:summary_keywords, [])
-      |> assign(:transcription_rows, [])
-      |> assign(:uploaded_file_name, filename)
-      |> assign(:transcriptions, list_transcriptions(socket.assigns.current_user))
-
-    {:noreply, socket}
+    {:ok, transcription} = Transcriptions.create_transcription(%{
+      user_id: socket.assigns.current_user.id,
+      filename: Enum.at(uploaded_files, 0)
+    })
+
+    Transcriptions.transcribe_audio(transcription)
+
+    {:noreply, push_navigate(socket, to: ~p"/transcriptions/#{transcription.id}")}
+    #
+    # socket =
+    #   socket
+    #   |> assign(:status, :loading)
+    #   |> assign(:summary_keywords, [])
+    #   |> assign(:transcription_rows, [])
+    #   |> assign(:uploaded_file_name, filename)
+    #   |> assign(:transcriptions, list_transcriptions(socket.assigns.current_user))
+    #
+    # {:noreply, socket}
   end
 
   @impl true
@@ -208,12 +213,6 @@ defmodule MedicalTranscriptionWeb.HomeLive.Index do
     {:noreply, assign(socket, :status, :success)}
   end
 
-  defp transcribe_and_tag_audio(audio_file_path) do
-    MedicalTranscription.Transcription.stream_transcription_and_search(
-      audio_file_path
-    )
-  end
-
   def error_to_string(:too_large), do: "Too large"
   def error_to_string(:not_accepted), do: "You have selected an unacceptable file type"
 

lib/medical_transcription_web/live/transcriptions_live/show.ex

@@ -0,0 +1,221 @@
+defmodule MedicalTranscriptionWeb.TranscriptionsLive.Show do
+  use MedicalTranscriptionWeb, :live_view
+
+  alias MedicalTranscription.Audio.RecordingPipeline
+  alias MedicalTranscription.Transcriptions
+
+  @impl Phoenix.LiveView
+  def mount(params, session, socket) do
+    dbg(params)
+    if connected?(socket), do: Phoenix.PubSub.subscribe(MedicalTranscription.PubSub, "transcriptions")
+
+    # We're storing atoms in `:status` as LiveView's AsyncResult doesn't support modeling a "pending" state, but only
+    # loading / ok / failed.
+    initial_state = %{
+      current_recording_id: 0,
+      uploaded_file_name: nil,
+      status: :pending,
+      audio_pipeline: nil,
+      summary_keywords: [],
+      transcriptions: list_transcriptions(session["current_user"]),
+      finalized_codes: []
+    }
+
+    socket =
+      socket
+      |> assign(initial_state)
+      |> stream_configure(:transcription_rows, dom_id: &"transcription-row-#{&1.id}")
+      |> stream(:transcription_rows, [])
+      |> allow_upload(:audio, accept: ~w(.mp3), max_entries: 1)
+
+    {:ok, socket}
+  end
+
+  @impl Phoenix.LiveView
+  def render(assigns) do
+    ~H"""
+    <div class="min-h-[calc(100vh-56px)] flex gap-5">
+      <MedicalTranscriptionWeb.Components.SidebarComponent.sidebar
+        current_user={@current_user}
+        transcriptions={@transcriptions}
+      />
+
+      <main class="flex-1 pl-16 pr-16 pt-[25px]">
+        <div class="flex flex-col h-full mx-auto max-w-5xl">
+          <div class="flex-1 flex flex-col space-y-6">
+            <%= if @status != :pending do %>
+              <.live_component
+                module={MedicalTranscriptionWeb.Components.ResultListComponent}
+                id="result_list"
+                rows={@streams.transcription_rows}
+                summary_keywords={@summary_keywords}
+                finalized_codes={@finalized_codes}
+              />
+            <% end %>
+
+            <%= if @status == :pending do %>
+              <div class="flex-1 flex flex-col justify-center items-center gap-4">
+                <img src={~p"/images/logo.svg"} width="106" />
+                <p class="text-2xl leading-normal font-semibold">Medical Code Transcriber</p>
+              </div>
+              <.upload_form audio_upload={@uploads.audio} />
+            <% end %>
+          </div>
+        </div>
+      </main>
+    </div>
+    """
+  end
+
+  @impl true
+  def handle_event("validate", _params, socket) do
+    {:noreply, socket}
+  end
+
+  @impl true
+  def handle_event("save", _params, socket) do
+    filename =
+      socket.assigns.uploads.audio.entries
+      |> Enum.at(0)
+      |> Map.get(:client_name)
+
+    uploaded_files =
+      consume_uploaded_entries(socket, :audio, fn %{path: path}, _entry ->
+        dest = Path.join(System.tmp_dir(), Path.basename(path))
+        File.cp!(path, dest)
+        {:ok, dest}
+      end)
+
+    {:ok, transcription} = Transcriptions.create_transcription(%{
+      user_id: socket.assigns.current_user.id,
+      filename: Enum.at(uploaded_files, 0)
+    })
+
+    Transcriptions.transcribe_audio(transcription)
+
+    socket =
+      socket
+      |> assign(:status, :loading)
+      |> assign(:summary_keywords, [])
+      |> assign(:transcription_rows, [])
+      |> assign(:uploaded_file_name, filename)
+      |> assign(:transcriptions, list_transcriptions(socket.assigns.current_user))
+
+    {:noreply, socket}
+  end
+
+  @impl true
+  def handle_event("add_feedback", params, socket) do
+    text_vector = MedicalTranscription.Coding.compute_vector_as_list(params["text"])
+
+    result =
+      params
+      |> Map.put("text_vector", text_vector)
+      |> MedicalTranscription.Feedback.track_response()
+
+    socket =
+      case result do
+        {:ok, message} -> put_flash(socket, :info, message)
+        {:error, messages} -> put_flash(socket, :error, messages)
+      end
+
+    {:noreply, socket}
+  end
+
+  @impl true
+  def handle_event("reset_to_pending", _params, socket) do
+    {:noreply, assign(socket, :status, :pending)}
+  end
+
+  @impl true
+  def handle_event("toggle_recording", _params, socket) do
+    socket =
+      if is_nil(socket.assigns.audio_pipeline) do
+        pipeline = RecordingPipeline.start_pipeline(self())
+
+        socket
+        |> assign(:status, :streaming_audio)
+        |> assign(:audio_pipeline, pipeline)
+      else
+        RecordingPipeline.stop_pipeline(socket.assigns.audio_pipeline)
+
+        socket
+        |> assign(:status, :success)
+        |> assign(:audio_pipeline, nil)
+      end
+
+    {:noreply, socket}
+  end
+
+  @impl true
+  def handle_info({:chunk, chunk_result}, socket) do
+    # The processing sends a message as each chunk of text is coded. See here for some background and potential
+    # inspiration for this: https://elixirforum.com/t/liveview-asynchronous-task-patterns/44695
+
+    {:noreply, stream_insert(socket, :transcription_rows, chunk_result)}
+  end
+
+  @impl true
+  def handle_info({:new_keywords, new_keywords}, socket) do
+    socket =
+      update(socket, :summary_keywords, fn keywords -> keywords ++ [new_keywords] end)
+
+    {:noreply, socket}
+  end
+
+  @impl true
+  def handle_info({:received_audio_payload, transcribed_text}, socket) do
+    tags = MedicalTranscription.Coding.process_chunk(transcribed_text)
+
+    result = %{
+      id: socket.assigns.current_recording_id + 1,
+      start_mark: nil,
+      end_mark: nil,
+      text: transcribed_text,
+      tags: tags
+    }
+
+    socket =
+      socket
+      |> assign(:status, :streaming_audio)
+      |> stream_insert(:transcription_rows, result)
+      |> assign(:current_recording_id, result.id)
+
+    {:noreply, socket}
+  end
+
+  @impl Phoenix.LiveView
+  def handle_info({"toggle_user_selected_code", {:add, code}}, socket) do
+    new_codes =
+      if Enum.any?(socket.assigns.finalized_codes, code) do
+        socket.assigns.finalized_codes
+      else
+        socket.assigns.finalized_codes ++ [code]
+      end
+
+    {:noreply, assign(socket, :finalized_codes, new_codes)}
+  end
+
+  @impl Phoenix.LiveView
+  def handle_info({"toggle_user_selected_code", {:remove, code}}, socket) do
+    new_codes = Enum.reject(socket.assigns.finalized_codes, &(&1 == code))
+
+    {:noreply, assign(socket, :finalized_codes, new_codes)}
+  end
+
+  @impl true
+  def handle_info({ref, _result}, socket) do
+    # See this Fly article for the usage of Task.async to start `transcribe_and_tag_audio/2` and handle the end of the
+    # task here: https://fly.io/phoenix-files/liveview-async-task/
+    Process.demonitor(ref, [:flush])
+
+    {:noreply, assign(socket, :status, :success)}
+  end
+
+  def error_to_string(:too_large), do: "Too large"
+  def error_to_string(:not_accepted), do: "You have selected an unacceptable file type"
+
+  defp list_transcriptions(user) do
+    Transcriptions.list_transcriptions(user)
+  end
+end

lib/medical_transcription_web/router.ex

@@ -74,6 +74,7 @@ defmodule MedicalTranscriptionWeb.Router do
       live "/users/settings", UserSettingsLive, :edit
       live "/users/settings/confirm_email/:token", UserSettingsLive, :confirm_email
       live "/", HomeLive.Index
+      live "/transcriptions/:id", TranscriptionsLive.Show
     end
   end
 

test/medical_transcription/transcription_server_test.exs

@@ -5,6 +5,8 @@ defmodule MedicalTranscription.TranscriptionServerTest do
 
   use MedicalTranscription.DataCase
 
+  import MedicalTranscription.TranscriptionsFixtures
+
   alias MedicalTranscription.TranscriptionServer
 
   setup do
@@ -13,11 +15,12 @@ defmodule MedicalTranscription.TranscriptionServerTest do
       |> Path.join("../../medasrdemo-Paul.mp3")
       |> Path.expand()
 
-    %{sample_file: sample_file}
+    transcription = transcription_fixture(%{filename: sample_file})
+    %{transcription: transcription}
   end
 
-  test "transcribe and tag audio", %{sample_file: sample_file} do
-    spec = {TranscriptionServer, file_path: sample_file}
+  test "transcribe and tag audio", %{transcription: transcription} do
+    spec = {TranscriptionServer, transcription: transcription}
 
     {:ok, pid} = start_supervised(spec)
 

test/medical_transcription_web/live/home_live_test.exs

@@ -2,17 +2,20 @@ defmodule MedicalTranscriptionWeb.HomeLiveTest do
   use MedicalTranscriptionWeb.ConnCase, async: true
 
   import Phoenix.LiveViewTest
-
   import MedicalTranscription.AccountsFixtures
+  import Ecto.Query
+
+  alias MedicalTranscription.Transcriptions.Transcription
+  alias MedicalTranscription.Repo
 
   setup %{conn: conn} do
     password = valid_user_password()
     user = user_fixture(%{password: password})
-    %{conn: log_in_user(conn, user)}
+    %{conn: log_in_user(conn, user), current_user: user}
   end
 
   describe "/" do
-    test "renders upload screen", %{conn: conn} do
+    test "renders upload screen", %{conn: conn, current_user: current_user} do
       # 1. Find file input
       # 2. Upload file
       # 3. Click submit
@@ -42,28 +45,20 @@ defmodule MedicalTranscriptionWeb.HomeLiveTest do
           }
         ])
 
-      # assert audio
-      #        |> render_upload("sample.mp3") =~ "Submitted: sample.mp3"
-      #
-      # refute view
-      #        |> form("#audio-form")
-      #        |> render_submit() =~ "Submitted: sample.mp3"
-
       render_upload(audio, "sample.mp3")
 
-      assert view
-             |> form("#audio-form")
-             |> render_submit() =~ "Transcribing and tagging audio file..."
+      view
+      |> form("#audio-form")
+      |> render_submit()
 
-      # TODO: Test that transcribed text appears
-      # TODO: Test that codes appear
-      # assert render_async(view, 5_000) =~ "Coronary artery anomaly"
-    end
+      transcription =
+        Transcription
+        |> where([t], t.user_id == ^current_user.id)
+        |> order_by(desc: :inserted_at)
+        |> limit(1)
+        |> Repo.one()
 
-    test "renders transcription text", %{conn: conn} do
-      {:ok, view, html} = live(conn, "/")
-      html = view |> element("result_list")
-      assert html_response(conn, 200)
+      assert_redirected view, ~p"/transcriptions/#{transcription.id}"
     end
   end
 end