Merge pull request #630 from NDLANO/support-several-language-codes

Support several language codes

Author: gunnarvelle

article-api/src/main/scala/no/ndla/articleapi/controller/ArticleControllerV2.scala

@@ -19,6 +19,7 @@ import no.ndla.articleapi.validation.ContentValidator
 import no.ndla.articleapi.Props
 import no.ndla.common.ContentURIUtil.parseArticleIdAndRevision
 import no.ndla.common.model.api.CommaSeparatedList.*
+import no.ndla.language.Language
 import no.ndla.language.Language.AllLanguages
 import no.ndla.network.tapir.NoNullJsonPrinter.jsonBody
 import no.ndla.network.tapir.Parameters.feideHeader
@@ -147,7 +148,7 @@ trait ArticleControllerV2 {
               queryOrEmpty,
               parsedPageSize,
               parsedPageNo,
-              language
+              Language.languageOrParam(language)
             )
             .asRight
         }
@@ -234,7 +235,7 @@ trait ArticleControllerV2 {
               search(
                 query,
                 sort,
-                language,
+                Language.languageOrParam(language),
                 license,
                 page,
                 pageSize,
@@ -275,7 +276,7 @@ trait ArticleControllerV2 {
         readService
           .getArticlesByIds(
             ids.values,
-            language,
+            Language.languageOrParam(language),
             fallback,
             page,
             pageSize,
@@ -310,7 +311,7 @@ trait ArticleControllerV2 {
           search(
             query,
             sort,
-            language,
+            Language.languageOrParam(language),
             license,
             page,
             pageSize,
@@ -337,10 +338,10 @@ trait ArticleControllerV2 {
         val (articleId, revisionQuery, feideToken, language, fallback) = params
         (parseArticleIdAndRevision(articleId) match {
           case (Failure(_), _) =>
-            readService.getArticleBySlug(articleId, language, fallback)
+            readService.getArticleBySlug(articleId, Language.languageOrParam(language), fallback)
           case (Success(articleId), inlineRevision) =>
             val revision = inlineRevision.orElse(revisionQuery)
-            readService.withIdV2(articleId, language, fallback, revision, feideToken)
+            readService.withIdV2(articleId, Language.languageOrParam(language), fallback, revision, feideToken)
         }).map(_.Ok())
       }
 

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

@@ -37,28 +37,23 @@ import java.io.File
 import scala.util.{Failure, Success, Try}
 
 trait AudioController {
-  this: AudioRepository
-    with ReadService
-    with WriteService
-    with AudioSearchService
-    with SearchConverterService
-    with ConverterService
-    with Props
-    with ErrorHandling
-    with TapirController =>
+  this: AudioRepository & ReadService & WriteService & AudioSearchService & SearchConverterService & ConverterService &
+    Props & ErrorHandling & TapirController =>
   val audioApiController: AudioController
 
-  class AudioController() extends TapirController {
-    import props._
-    val maxAudioFileSizeBytes                = props.MaxAudioFileSizeBytes
+  class AudioController extends TapirController {
+    import props.*
+    val maxAudioFileSizeBytes: Int           = props.MaxAudioFileSizeBytes
     override val serviceName: String         = "audio"
     override val prefix: EndpointInput[Unit] = "audio-api" / "v1" / serviceName
 
     private val queryString = query[Option[NonEmptyString]]("query")
       .description("Return only results with titles or tags matching the specified query.")
       .schema(NonEmptyString.schemaOpt)
     private val language =
-      query[Option[String]]("language").description("The ISO 639-1 language code describing language.")
+      query[Option[String]]("language")
+        .description("The ISO 639-1 language code describing language.")
+        .default(Some(Language.AllLanguages))
     private val license = query[Option[String]]("license").description("Return only audio with provided license.")
     private val pageNo  = query[Option[Int]]("page").description("The page number of the search hits to display.")
     private val pageSize = query[Option[Int]]("page-size").description(
@@ -95,7 +90,7 @@ trait AudioController {
     private val pathAudioId  = path[Long]("audio-id").description("Id of audio.")
     private val pathLanguage = path[String]("language").description("The ISO 639-1 language code describing language.")
 
-    import ErrorHelpers._
+    import ErrorHelpers.*
 
     def getSearch: ServerEndpoint[Any, Eff] = endpoint.get
       .summary("Find audio files")
@@ -341,7 +336,7 @@ trait AudioController {
         case Some(q) =>
           SearchSettings(
             query = Some(q),
-            language = language,
+            language = language.map(Language.languageOrParam),
             license = license,
             page = page,
             pageSize = pageSize,
@@ -355,7 +350,7 @@ trait AudioController {
         case None =>
           SearchSettings(
             query = None,
-            language = language,
+            language = language.map(Language.languageOrParam),
             license = license,
             page = page,
             pageSize = pageSize,

audio-api/src/main/scala/no/ndla/audioapi/repository/AudioRepository.scala

@@ -20,7 +20,7 @@ import scalikejdbc.*
 import scala.util.{Failure, Success, Try}
 
 trait AudioRepository {
-  this: DataSource with SeriesRepository with Props with ErrorHandling =>
+  this: DataSource & SeriesRepository & Props & ErrorHandling =>
   val audioRepository: AudioRepository
 
   class AudioRepository extends StrictLogging with Repository[AudioMetaInformation] {

audio-api/src/main/scala/no/ndla/audioapi/repository/SeriesRepository.scala

@@ -23,7 +23,7 @@ import no.ndla.database.DataSource
 import scala.util.{Failure, Success, Try}
 
 trait SeriesRepository {
-  this: DataSource with Props with ErrorHandling =>
+  this: DataSource & Props & ErrorHandling =>
   val seriesRepository: SeriesRepository
 
   class SeriesRepository extends StrictLogging with Repository[Series] {

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

@@ -17,7 +17,7 @@ import no.ndla.common.errors.{NotFoundException, ValidationException}
 import scala.util.{Failure, Success, Try}
 
 trait ReadService {
-  this: AudioRepository with SeriesRepository with ConverterService with TagSearchService with SearchConverterService =>
+  this: AudioRepository & SeriesRepository & ConverterService & TagSearchService & SearchConverterService =>
   val readService: ReadService
 
   class ReadService {
@@ -27,7 +27,7 @@ trait ReadService {
         case Failure(ex) => Failure(ex)
         case Success(None) =>
           Failure(
-            new NotFoundException(
+            NotFoundException(
               s"The series with id '$seriesId' and language '${language.getOrElse("")}' was not found."
             )
           )

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

@@ -36,10 +36,10 @@ trait TranscriptionService {
       getVideoTranscription(videoId, language) match {
         case Success(TranscriptionComplete(_)) =>
           logger.info(s"Transcription already completed for videoId: $videoId")
-          return Failure(new JobAlreadyFoundException(s"Transcription already completed for videoId: $videoId"))
+          return Failure(JobAlreadyFoundException(s"Transcription already completed for videoId: $videoId"))
         case Success(TranscriptionNonComplete(TranscriptionJobStatus.IN_PROGRESS)) =>
           logger.info(s"Transcription already in progress for videoId: $videoId")
-          return Failure(new JobAlreadyFoundException(s"Transcription already in progress for videoId: $videoId"))
+          return Failure(JobAlreadyFoundException(s"Transcription already in progress for videoId: $videoId"))
         case _ =>
           logger.info(s"No existing transcription job for videoId: $videoId")
       }
@@ -93,7 +93,7 @@ trait TranscriptionService {
         val transcriptionJobStatus = transcriptionJob.transcriptionJobStatus()
 
         if (transcriptionJobStatus == "COMPLETED") {
-          val transcribeUri = s"transcription/$language/${videoId}.vtt"
+          val transcribeUri = s"transcription/$language/$videoId.vtt"
 
           getObjectFromS3(transcribeUri).map(TranscriptionComplete(_))
         } else {
@@ -112,10 +112,10 @@ trait TranscriptionService {
       getAudioTranscription(audioId, language) match {
         case Success(Right(_)) =>
           logger.info(s"Transcription already completed for audio: $audioName")
-          return Failure(new JobAlreadyFoundException(s"Transcription already completed for audio: $audioName"))
+          return Failure(JobAlreadyFoundException(s"Transcription already completed for audio: $audioName"))
         case Success(Left("IN_PROGRESS")) =>
           logger.info(s"Transcription already in progress for videoId: $audioName")
-          return Failure(new JobAlreadyFoundException(s"Transcription already in progress for audio: $audioName"))
+          return Failure(JobAlreadyFoundException(s"Transcription already in progress for audio: $audioName"))
         case _ =>
           logger.info(s"No existing transcription job for audio name: $audioName")
       }
@@ -151,7 +151,7 @@ trait TranscriptionService {
         val transcriptionJobStatus = transcriptionJob.transcriptionJobStatus().toString
 
         if (transcriptionJobStatus == "COMPLETED") {
-          val transcribeUri = s"audio-transcription/$language/${audioId}"
+          val transcribeUri = s"audio-transcription/$language/$audioId"
 
           getObjectFromS3(transcribeUri).map(Right(_))
         } else {
@@ -180,7 +180,7 @@ trait TranscriptionService {
         case Failure(ex)   => throw new RuntimeException(s"Failed to download video: $ex")
       }
 
-      val audioFile = new File(s"/tmp/audio_${videoId}.mp3")
+      val audioFile = new File(s"/tmp/audio_$videoId.mp3")
 
       val audioAttributes = new AudioAttributes()
       audioAttributes.setCodec("libmp3lame")
@@ -221,7 +221,7 @@ trait TranscriptionService {
     }
 
     def getAudioExtractionStatus(videoId: String, language: String): Try[Unit] = {
-      s3TranscribeClient.getObject(s"audio-extraction/$language/${videoId}.mp3") match {
+      s3TranscribeClient.getObject(s"audio-extraction/$language/$videoId.mp3") match {
         case Success(_)         => Success(())
         case Failure(exception) => Failure(exception)
       }

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

@@ -27,24 +27,16 @@ import java.lang.Math.max
 import scala.util.{Failure, Random, Success, Try}
 
 trait WriteService {
-  this: ConverterService
-    with ValidationService
-    with AudioRepository
-    with SeriesRepository
-    with AudioIndexService
-    with SeriesIndexService
-    with TagIndexService
-    with NdlaS3Client
-    with ReadService
-    with Clock =>
+  this: ConverterService & ValidationService & AudioRepository & SeriesRepository & AudioIndexService &
+    SeriesIndexService & TagIndexService & NdlaS3Client & ReadService & Clock =>
   val writeService: WriteService
 
   class WriteService extends StrictLogging {
 
     def updateSeries(id: Long, toUpdateSeries: api.NewSeriesDTO): Try[api.SeriesDTO] = {
       seriesRepository.withId(id) match {
         case Failure(ex)   => Failure(ex)
-        case Success(None) => Failure(new NotFoundException(s"Could not find series to update with id: '$id'"))
+        case Success(None) => Failure(NotFoundException(s"Could not find series to update with id: '$id'"))
         case Success(Some(existingSeries)) =>
           val merged             = converterService.updateSeries(existingSeries, toUpdateSeries)
           val oldEpisodesIds     = existingSeries.episodes.traverse(_.flatMap(_.id)).flatten.toSet
@@ -85,7 +77,7 @@ trait WriteService {
 
     }
 
-    def updateSeriesForEpisodes(seriesId: Option[Long], episodeIds: Seq[Long]): Try[_] =
+    def updateSeriesForEpisodes(seriesId: Option[Long], episodeIds: Seq[Long]): Try[?] =
       episodeIds.traverse(id =>
         for {
           _ <- audioRepository.setSeriesId(
@@ -95,7 +87,7 @@ trait WriteService {
           episode <- audioRepository.withId(id) match {
             case Some(ep) => Success(ep)
             case None =>
-              Failure(new NotFoundException(s"Could not find episode with id '$id' when updating series connection."))
+              Failure(NotFoundException(s"Could not find episode with id '$id' when updating series connection."))
           }
           reindexed <- audioIndexService.indexDocument(episode)
         } yield reindexed
@@ -105,7 +97,7 @@ trait WriteService {
       seriesRepository.withId(seriesId) match {
         case Failure(ex) => Failure(ex)
         case Success(None) =>
-          Failure(new NotFoundException(s"Series with id $seriesId was not found, and could not be deleted."))
+          Failure(NotFoundException(s"Series with id $seriesId was not found, and could not be deleted."))
         case Success(Some(existingSeries)) =>
           val episodes = existingSeries.episodes.getOrElse(Seq.empty)
           freeEpisodes(episodes) match {
@@ -114,7 +106,7 @@ trait WriteService {
               seriesRepository.deleteWithId(seriesId) match {
                 case Success(numRows) if numRows > 0 => seriesIndexService.deleteDocument(seriesId)
                 case Success(_) =>
-                  Failure(new NotFoundException(s"Could not find series to delete with id: '$seriesId'"))
+                  Failure(NotFoundException(s"Could not find series to delete with id: '$seriesId'"))
                 case Failure(ex) => Failure(ex)
               }
           }
@@ -159,9 +151,9 @@ trait WriteService {
           }
 
         case Some(_) =>
-          Failure(new NotFoundException(s"Audio with id $audioId does not exist in language '$language'."))
+          Failure(NotFoundException(s"Audio with id $audioId does not exist in language '$language'."))
         case None =>
-          Failure(new NotFoundException(s"Audio with id $audioId was not found, and could not be deleted."))
+          Failure(NotFoundException(s"Audio with id $audioId was not found, and could not be deleted."))
       }
 
     def deleteSeriesLanguageVersion(seriesId: Long, language: String): Try[Option[api.SeriesDTO]] = {
@@ -182,9 +174,9 @@ trait WriteService {
             } yield result
           }
         case Success(Some(_)) =>
-          Failure(new NotFoundException(s"Series with id $seriesId does not exist in language '$language'."))
+          Failure(NotFoundException(s"Series with id $seriesId does not exist in language '$language'."))
         case Success(None) =>
-          Failure(new NotFoundException(s"Series with id $seriesId was not found, and could not be deleted."))
+          Failure(NotFoundException(s"Series with id $seriesId was not found, and could not be deleted."))
         case Failure(ex) => Failure(ex)
       }
     }
@@ -255,7 +247,7 @@ trait WriteService {
 
           if (metaDeleted < 1) {
             Failure(
-              new NotFoundException(s"Metadata for audio with id $audioId was not found, and could not be deleted.")
+              NotFoundException(s"Metadata for audio with id $audioId was not found, and could not be deleted.")
             )
           } else if (filesDeleted.exists(_.isFailure)) {
             val exceptions = filesDeleted.collect { case Failure(ex) => ex }
@@ -268,7 +260,7 @@ trait WriteService {
             }
           }
 
-        case None => Failure(new NotFoundException(s"Audio with id $audioId was not found, and could not be deleted."))
+        case None => Failure(NotFoundException(s"Audio with id $audioId was not found, and could not be deleted."))
       }
     }
 

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

@@ -24,17 +24,12 @@ import no.ndla.search.Elastic4sClient
 import scala.util.{Failure, Try}
 
 trait AudioIndexService {
-  this: Elastic4sClient
-    with SearchConverterService
-    with IndexService
-    with SeriesIndexService
-    with AudioRepository
-    with Props =>
+  this: Elastic4sClient & SearchConverterService & IndexService & SeriesIndexService & AudioRepository & Props =>
 
   val audioIndexService: AudioIndexService
 
   class AudioIndexService extends StrictLogging with IndexService[AudioMetaInformation, SearchableAudioInformation] {
-    import props._
+    import props.*
     override val documentType: String        = SearchDocument
     override val searchIndex: String         = SearchIndex
     override val repository: AudioRepository = audioRepository

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

@@ -27,16 +27,11 @@ import scala.concurrent.Future
 import scala.util.{Failure, Success, Try}
 
 trait AudioSearchService {
-  this: Elastic4sClient
-    with AudioIndexService
-    with SearchConverterService
-    with SearchService
-    with Props
-    with ErrorHandling =>
+  this: Elastic4sClient & AudioIndexService & SearchConverterService & SearchService & Props & ErrorHandling =>
   val audioSearchService: AudioSearchService
 
   class AudioSearchService extends StrictLogging with SearchService[api.AudioSummaryDTO] {
-    import props._
+    import props.*
 
     override val searchIndex: String = SearchIndex
 

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

@@ -8,16 +8,16 @@
 
 package no.ndla.audioapi.service.search
 
-import cats.implicits._
+import cats.implicits.*
 import com.sksamuel.elastic4s.requests.searches.SearchHit
 import com.typesafe.scalalogging.StrictLogging
 import no.ndla.audioapi.Props
 import no.ndla.audioapi.model.api.TitleDTO
 import no.ndla.audioapi.model.domain.{AudioMetaInformation, SearchResult, SearchableTag}
-import no.ndla.audioapi.model.search._
+import no.ndla.audioapi.model.search.*
 import no.ndla.audioapi.model.{api, domain}
 import no.ndla.audioapi.service.ConverterService
-import no.ndla.common.model.{domain => common}
+import no.ndla.common.model.domain as common
 import no.ndla.language.Language.{findByLanguageOrBestEffort, getSupportedLanguages}
 import no.ndla.search.SearchLanguage
 import no.ndla.search.model.{LanguageValue, SearchableLanguageList, SearchableLanguageValues}
@@ -181,7 +181,7 @@ trait SearchConverterService {
           .lastOption
       }
 
-      val highlightKeys: Option[Map[String, _]] = Option(result.highlight)
+      val highlightKeys: Option[Map[String, ?]] = Option(result.highlight)
       val matchLanguage                         = keyToLanguage(highlightKeys.getOrElse(Map()).keys)
 
       matchLanguage match {