Endpoint to transcribe videos

audio-api/src/main/scala/no/ndla/audioapi/AudioApiProperties.scala

@@ -9,6 +9,7 @@
 package no.ndla.audioapi
 
 import com.typesafe.scalalogging.StrictLogging
+import no.ndla.common.Environment.prop
 import no.ndla.common.configuration.{BaseProps, HasBaseProps}
 import no.ndla.database.{DatabaseProps, HasDatabaseProps}
 import no.ndla.network.{AuthUser, Domains}
@@ -36,6 +37,13 @@ class AudioApiProperties extends BaseProps with DatabaseProps with StrictLogging
   val StorageName: String           = propOrElse("AUDIO_FILE_S3_BUCKET", s"$Environment.audio.ndla")
   val StorageRegion: Option[String] = propOrNone("AUDIO_FILE_S3_BUCKET_REGION")
 
+  val TranscribeStorageName: String = propOrElse("TRANSCRIBE_FILE_S3_BUCKET_NAME", s"$Environment.transcribe.ndla")
+  val TranscribeStorageRegion: Option[String] = propOrNone("TRANSCRIBE_FILE_S3_BUCKET_REGION")
+
+  val BrightcoveClientId: String     = prop("BRIGHTCOVE_API_CLIENT_ID")
+  val BrightcoveClientSecret: String = prop("BRIGHTCOVE_API_CLIENT_SECRET")
+  val BrightcoveAccountId: String    = prop("NDLA_BRIGHTCOVE_ACCOUNT_ID")
+
   val SearchServer: String                 = propOrElse("SEARCH_SERVER", "http://search-audio-api.ndla-local")
   val RunWithSignedSearchRequests: Boolean = propOrElse("RUN_WITH_SIGNED_SEARCH_REQUESTS", "true").toBoolean
   val SearchIndex: String                  = propOrElse("SEARCH_INDEX_NAME", "audios")

audio-api/src/main/scala/no/ndla/audioapi/ComponentRegistry.scala

@@ -16,7 +16,8 @@ import no.ndla.audioapi.repository.{AudioRepository, SeriesRepository}
 import no.ndla.audioapi.service.*
 import no.ndla.audioapi.service.search.*
 import no.ndla.common.Clock
-import no.ndla.common.aws.NdlaS3Client
+import no.ndla.common.aws.{NdlaAWSTranscribeClient, NdlaS3Client}
+import no.ndla.common.brightcove.NdlaBrightcoveClient
 import no.ndla.common.configuration.BaseComponentRegistry
 import no.ndla.database.{DBMigrator, DataSource}
 import no.ndla.network.NdlaClient
@@ -38,6 +39,7 @@ class ComponentRegistry(properties: AudioApiProperties)
     with HealthController
     with AudioController
     with SeriesController
+    with TranscriptionController
     with SearchService
     with AudioSearchService
     with SeriesSearchService
@@ -54,7 +56,10 @@ class ComponentRegistry(properties: AudioApiProperties)
     with DBMigrator
     with ErrorHandling
     with SwaggerDocControllerConfig
-    with NdlaS3Client {
+    with NdlaS3Client
+    with TranscriptionService
+    with NdlaAWSTranscribeClient
+    with NdlaBrightcoveClient {
   override val props: AudioApiProperties = properties
   override val migrator: DBMigrator = DBMigrator(
     new V5__AddAgreementToAudio,
@@ -63,23 +68,28 @@ class ComponentRegistry(properties: AudioApiProperties)
   override val dataSource: HikariDataSource = DataSource.getHikariDataSource
   DataSource.connectToDatabase()
 
-  lazy val s3Client = new NdlaS3Client(props.StorageName, props.StorageRegion)
+  lazy val s3Client           = new NdlaS3Client(props.StorageName, props.StorageRegion)
+  lazy val s3TranscribeClient = new NdlaS3Client(props.TranscribeStorageName, props.TranscribeStorageRegion)
+  lazy val brightcoveClient   = new NdlaBrightcoveClient()
+  lazy val transcribeClient   = new NdlaAWSTranscribeClient(props.TranscribeStorageRegion)
 
   lazy val audioRepository  = new AudioRepository
   lazy val seriesRepository = new SeriesRepository
 
   lazy val ndlaClient                       = new NdlaClient
   lazy val myndlaApiClient: MyNDLAApiClient = new MyNDLAApiClient
 
-  lazy val readService       = new ReadService
-  lazy val writeService      = new WriteService
-  lazy val validationService = new ValidationService
-  lazy val converterService  = new ConverterService
+  lazy val readService          = new ReadService
+  lazy val writeService         = new WriteService
+  lazy val validationService    = new ValidationService
+  lazy val converterService     = new ConverterService
+  lazy val transcriptionService = new TranscriptionService
 
-  lazy val internController   = new InternController
-  lazy val audioApiController = new AudioController
-  lazy val seriesController   = new SeriesController
-  lazy val healthController   = new HealthController
+  lazy val internController        = new InternController
+  lazy val audioApiController      = new AudioController
+  lazy val seriesController        = new SeriesController
+  lazy val healthController        = new HealthController
+  lazy val transcriptionController = new TranscriptionController
 
   var e4sClient: NdlaE4sClient    = Elastic4sClientFactory.getClient(props.SearchServer)
   lazy val searchConverterService = new SearchConverterService
@@ -97,7 +107,8 @@ class ComponentRegistry(properties: AudioApiProperties)
       audioApiController,
       seriesController,
       internController,
-      healthController
+      healthController,
+      transcriptionController
     ),
     SwaggerDocControllerConfig.swaggerInfo
   )

audio-api/src/main/scala/no/ndla/audioapi/controller/InternController.scala

@@ -12,11 +12,12 @@ import cats.implicits.*
 import io.circe.generic.auto.*
 import no.ndla.audioapi.Props
 import no.ndla.audioapi.model.api
-import no.ndla.audioapi.model.api.{AudioMetaDomainDumpDTO, ErrorHandling, NotFoundException}
+import no.ndla.audioapi.model.api.{AudioMetaDomainDumpDTO, ErrorHandling}
 import no.ndla.audioapi.model.domain.AudioMetaInformation
 import no.ndla.audioapi.repository.AudioRepository
 import no.ndla.audioapi.service.search.{AudioIndexService, SeriesIndexService, TagIndexService}
 import no.ndla.audioapi.service.{ConverterService, ReadService}
+import no.ndla.common.errors.NotFoundException
 import no.ndla.network.tapir.NoNullJsonPrinter.jsonBody
 import no.ndla.network.tapir.TapirController
 import no.ndla.network.tapir.TapirUtil.errorOutputsFor
@@ -116,7 +117,7 @@ trait InternController {
         .serverLogicPure { id =>
           audioRepository.withId(id) match {
             case Some(image) => image.asRight
-            case None        => returnLeftError(new NotFoundException(s"Could not find audio with id: '$id'"))
+            case None        => returnLeftError(NotFoundException(s"Could not find audio with id: '$id'"))
           }
         },
       endpoint.post

audio-api/src/main/scala/no/ndla/audioapi/controller/TranscriptionController.scala

@@ -0,0 +1,169 @@
+/*
+ * Part of NDLA audio-api
+ * Copyright (C) 2024 NDLA
+ *
+ * See LICENSE
+ *
+ */
+
+package no.ndla.audioapi.controller
+
+import no.ndla.audioapi.Props
+import no.ndla.audioapi.model.api.{JobAlreadyFoundException, TranscriptionResultDTO}
+import no.ndla.audioapi.service.{ReadService, TranscriptionService}
+import no.ndla.network.tapir.NoNullJsonPrinter.jsonBody
+import no.ndla.network.tapir.TapirController
+import no.ndla.network.tapir.TapirUtil.errorOutputsFor
+import no.ndla.network.tapir.auth.Permission.DRAFT_API_WRITE
+import sttp.tapir.server.ServerEndpoint
+import sttp.tapir.{EndpointInput, endpoint, path}
+import sttp.tapir.*
+import sttp.tapir.generic.auto.schemaForCaseClass
+
+import scala.util.{Failure, Success}
+trait TranscriptionController {
+  this: Props & TapirController & ReadService & TranscriptionService =>
+  val transcriptionController: TranscriptionController
+  class TranscriptionController() extends TapirController {
+
+    override val serviceName: String         = "transcription"
+    override val prefix: EndpointInput[Unit] = "audio-api" / "v1" / serviceName
+
+    private val videoId   = path[String]("videoId").description("The video id to transcribe")
+    private val audioName = path[String]("audioName").description("The audio name to transcribe")
+    private val audioId   = path[Long]("audioId").description("The audio id to transcribe")
+    private val language  = path[String]("language").description("The language to transcribe the video to")
+    private val maxSpeaker =
+      query[Int]("maxSpeaker").description("The maximum number of speakers in the video").default(2)
+    private val format = query[String]("format").description("The format of the audio file").default("mp3")
+
+    def postExtractAudio: ServerEndpoint[Any, Eff] = endpoint.post
+      .summary("Extract audio from video")
+      .description("Extracts audio from a Brightcove video and uploads it to S3.")
+      .in(videoId)
+      .in(language)
+      .in("extract-audio")
+      .errorOut(errorOutputsFor(400, 500))
+      .requirePermission(DRAFT_API_WRITE)
+      .serverLogicPure { _ =>
+        { case (videoId, language) =>
+          transcriptionService.extractAudioFromVideo(videoId, language) match {
+            case Success(_)  => Right(())
+            case Failure(ex) => returnLeftError(ex)
+          }
+        }
+      }
+
+    def getAudioExtraction: ServerEndpoint[Any, Eff] = endpoint.get
+      .summary("Get audio extraction status")
+      .description("Get the status of the audio extraction from a Brightcove video.")
+      .in(videoId)
+      .in(language)
+      .in("extract-audio")
+      .errorOut(errorOutputsFor(400, 500))
+      .requirePermission(DRAFT_API_WRITE)
+      .serverLogicPure { _ =>
+        { case (videoId, language) =>
+          transcriptionService.getAudioExtractionStatus(videoId, language) match {
+            case Success(_)  => Right(())
+            case Failure(ex) => returnLeftError(ex)
+          }
+        }
+      }
+
+    def postTranscription: ServerEndpoint[Any, Eff] = endpoint.post
+      .summary("Transcribe video")
+      .description("Transcribes a video and uploads the transcription to S3.")
+      .in(videoId)
+      .in(language)
+      .in(maxSpeaker)
+      .errorOut(errorOutputsFor(400, 500))
+      .requirePermission(DRAFT_API_WRITE)
+      .serverLogicPure { _ =>
+        { case (videoId, language, maxSpeakerOpt) =>
+          transcriptionService.transcribeVideo(videoId, language, maxSpeakerOpt) match {
+            case Success(_) => Right(())
+            case Failure(ex: JobAlreadyFoundException) =>
+              returnLeftError(ex)
+            case Failure(ex) => returnLeftError(ex)
+          }
+        }
+      }
+
+    def getTranscription: ServerEndpoint[Any, Eff] = endpoint.get
+      .summary("Get the transcription status of a video")
+      .description("Get the transcription of a video.")
+      .in(videoId)
+      .in(language)
+      .errorOut(errorOutputsFor(400, 404, 405, 500))
+      .out(jsonBody[TranscriptionResultDTO])
+      .requirePermission(DRAFT_API_WRITE)
+      .serverLogicPure { _ =>
+        { case (videoId, language) =>
+          transcriptionService.getVideoTranscription(videoId, language) match {
+            case Success(Right(transcriptionContent)) =>
+              Right(TranscriptionResultDTO("COMPLETED", Some(transcriptionContent)))
+            case Success(Left(jobStatus)) =>
+              Right(TranscriptionResultDTO(jobStatus.toString, None))
+            case Failure(ex: NoSuchElementException) => returnLeftError(ex)
+            case Failure(ex)                         => returnLeftError(ex)
+          }
+        }
+      }
+
+    def postAudioTranscription: ServerEndpoint[Any, Eff] = endpoint.post
+      .summary("Transcribe audio")
+      .description("Transcribes a video and uploads the transcription to S3.")
+      .in("audio")
+      .in(audioName)
+      .in(audioId)
+      .in(language)
+      .in(maxSpeaker)
+      .in(format)
+      .errorOut(errorOutputsFor(400, 500))
+      .requirePermission(DRAFT_API_WRITE)
+      .serverLogicPure { _ =>
+        { case (audioName, audioId, language, maxSpeakerOpt, format) =>
+          transcriptionService.transcribeAudio(audioName, audioId, language, maxSpeakerOpt, format) match {
+            case Success(_) => Right(())
+            case Failure(ex: JobAlreadyFoundException) =>
+              returnLeftError(ex)
+            case Failure(ex) => returnLeftError(ex)
+          }
+        }
+      }
+
+    def getAudioTranscription: ServerEndpoint[Any, Eff] = endpoint.get
+      .summary("Get the transcription status of a video")
+      .description("Get the transcription of a video.")
+      .in("audio")
+      .in(audioId)
+      .in(language)
+      .errorOut(errorOutputsFor(400, 404, 405, 500))
+      .out(jsonBody[TranscriptionResultDTO])
+      .requirePermission(DRAFT_API_WRITE)
+      .serverLogicPure { _ =>
+        { case (audioId, language) =>
+          transcriptionService.getAudioTranscription(audioId, language) match {
+            case Success(Right(transcriptionContent)) =>
+              Right(TranscriptionResultDTO("COMPLETED", Some(transcriptionContent)))
+            case Success(Left(jobStatus)) =>
+              Right(TranscriptionResultDTO(jobStatus.toString, None))
+            case Failure(ex: NoSuchElementException) => returnLeftError(ex)
+            case Failure(ex)                         => returnLeftError(ex)
+          }
+        }
+      }
+
+    override val endpoints: List[ServerEndpoint[Any, Eff]] =
+      List(
+        postExtractAudio,
+        getAudioExtraction,
+        postTranscription,
+        getTranscription,
+        postAudioTranscription,
+        getAudioTranscription
+      )
+  }
+
+}

audio-api/src/main/scala/no/ndla/audioapi/model/api/Error.scala

@@ -10,7 +10,7 @@ package no.ndla.audioapi.model.api
 
 import no.ndla.audioapi.Props
 import no.ndla.common.Clock
-import no.ndla.common.errors.{AccessDeniedException, FileTooBigException, ValidationException}
+import no.ndla.common.errors.{AccessDeniedException, FileTooBigException, NotFoundException, ValidationException}
 import no.ndla.database.DataSource
 import no.ndla.network.model.HttpRequestException
 import no.ndla.network.tapir.{AllErrors, ErrorBody, TapirErrorHandling, ValidationErrorBody}
@@ -55,13 +55,14 @@ trait ErrorHandling extends TapirErrorHandling {
         if rf.error.rootCause
           .exists(x => x.`type` == "search_context_missing_exception" || x.reason == "Cannot parse scroll id") =>
       invalidSearchContext
+    case jafe: JobAlreadyFoundException => ErrorBody(JOB_ALREADY_FOUND, jafe.getMessage, clock.now(), 400)
   }
 
 }
 
-class NotFoundException(message: String = "The audio was not found") extends RuntimeException(message)
-case class MissingIdException(message: String)                       extends RuntimeException(message)
-case class CouldNotFindLanguageException(message: String)            extends RuntimeException(message)
-class AudioStorageException(message: String)                         extends RuntimeException(message)
-class LanguageMappingException(message: String)                      extends RuntimeException(message)
-class ImportException(message: String)                               extends RuntimeException(message)
+case class MissingIdException(message: String)            extends RuntimeException(message)
+case class CouldNotFindLanguageException(message: String) extends RuntimeException(message)
+class AudioStorageException(message: String)              extends RuntimeException(message)
+class LanguageMappingException(message: String)           extends RuntimeException(message)
+class ImportException(message: String)                    extends RuntimeException(message)
+case class JobAlreadyFoundException(message: String)      extends RuntimeException(message)

audio-api/src/main/scala/no/ndla/audioapi/model/api/TranscriptionResultDTO.scala

@@ -0,0 +1,23 @@
+/*
+ * Part of NDLA audio-api
+ * Copyright (C) 2024 NDLA
+ *
+ * See LICENSE
+ *
+ */
+
+package no.ndla.audioapi.model.api
+
+import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}
+import io.circe.{Decoder, Encoder}
+import sttp.tapir.Schema.annotations.description
+
+@description("The result of a transcription job")
+case class TranscriptionResultDTO(
+    @description("The status of the transcription job") status: String,
+    @description("The transcription of the audio") transcription: Option[String]
+)
+object TranscriptionResultDTO {
+  implicit val encoder: Encoder[TranscriptionResultDTO] = deriveEncoder
+  implicit val decoder: Decoder[TranscriptionResultDTO] = deriveDecoder
+}

audio-api/src/main/scala/no/ndla/audioapi/service/ReadService.scala

@@ -8,12 +8,11 @@
 
 package no.ndla.audioapi.service
 
-import cats.implicits._
+import cats.implicits.*
 import no.ndla.audioapi.model.api
-import no.ndla.audioapi.model.api.NotFoundException
 import no.ndla.audioapi.repository.{AudioRepository, SeriesRepository}
 import no.ndla.audioapi.service.search.{SearchConverterService, TagSearchService}
-import no.ndla.common.errors.ValidationException
+import no.ndla.common.errors.{NotFoundException, ValidationException}
 
 import scala.util.{Failure, Success, Try}