Fix code smells and duplications on Sonar

src/main/kotlin/fr/shikkanime/controllers/site/SiteController.kt

@@ -17,7 +17,6 @@ import fr.shikkanime.utils.routes.Path
 import fr.shikkanime.utils.routes.Response
 import fr.shikkanime.utils.routes.method.Get
 import fr.shikkanime.utils.routes.param.PathParam
-import fr.shikkanime.utils.routes.param.QueryParam
 import io.ktor.http.*
 import java.time.ZonedDateTime
 
@@ -149,15 +148,8 @@ class SiteController {
 
     @Path("search")
     @Get
-    private fun search(
-        @QueryParam("q") query: String?,
-    ): Response {
-        return Response.template(
-            Link.SEARCH,
-            mutableMapOf(
-                "query" to query
-            )
-        )
+    private fun search(): Response {
+        return Response.template(Link.SEARCH)
     }
 
     @Path("calendar")

src/main/kotlin/fr/shikkanime/dtos/EpisodeMappingDto.kt

@@ -12,7 +12,7 @@ data class EpisodeMappingDto(
     val releaseDateTime: String,
     val lastReleaseDateTime: String,
     val lastUpdateDateTime: String,
-    val episodeType: EpisodeType,
+    var episodeType: EpisodeType,
     val season: Int,
     val number: Int,
     val duration: Long,

src/main/kotlin/fr/shikkanime/jobs/FetchEpisodesJob.kt

@@ -99,7 +99,12 @@ class FetchEpisodesJob : AbstractJob {
                 typeIdentifiers.add(typeIdentifier)
                 val episodeDto = AbstractConverter.convert(episode, EpisodeVariantDto::class.java)
                 sendToSocialNetworks(episodeDto)
-                FirebaseNotification.send(episodeDto)
+
+                try {
+                    FirebaseNotification.send(episodeDto)
+                } catch (e: Exception) {
+                    logger.log(Level.SEVERE, "Error while sending notification for episode ${episodeDto.identifier}", e)
+                }
             }
         }
     }

src/main/kotlin/fr/shikkanime/modules/Routing.kt

@@ -75,14 +75,16 @@ private fun setSecurityHeaders(call: ApplicationCall, configCacheService: Config
             HttpHeaders.StrictTransportSecurity,
             "max-age=${Constant.DEFAULT_CACHE_DURATION}; includeSubDomains; preload"
         )
-        context.response.header("Content-Security-Policy", "default-src 'self'; " +
-                "img-src data: 'self' 'unsafe-inline' 'unsafe-eval' https://api.shikkanime.fr https://www.shikkanime.fr; " +
-                "style-src 'self' 'unsafe-inline' 'unsafe-eval' https://cdn.jsdelivr.net; " +
-                "font-src 'self' https://cdn.jsdelivr.net; " +
-                "script-src 'self' 'unsafe-inline' 'unsafe-eval' https://cdn.jsdelivr.net; " +
-                configCacheService.getValueAsString(ConfigPropertyKey.ANALYTICS_API)
-                    ?.let { "connect-src 'self' $it; " }
+
+        context.response.header(
+            "Content-Security-Policy",
+            "default-src 'self'; font-src 'self';" +
+                    "style-src 'self' 'unsafe-inline' 'unsafe-eval';" +
+                    "script-src 'self' 'unsafe-inline' 'unsafe-eval';" +
+                    "img-src data: 'self' ${Constant.apiUrl} ${Constant.baseUrl};" +
+                    "connect-src 'self' ${Constant.apiUrl} ${configCacheService.getValueAsString(ConfigPropertyKey.ANALYTICS_API) ?: ""};"
         )
+
         context.response.header("X-Frame-Options", "DENY")
         context.response.header("X-Content-Type-Options", "nosniff")
         context.response.header("Referrer-Policy", "no-referrer")

src/main/kotlin/fr/shikkanime/platforms/AbstractPlatform.kt

@@ -1,5 +1,6 @@
 package fr.shikkanime.platforms
 
+import com.google.gson.JsonObject
 import fr.shikkanime.entities.enums.CountryCode
 import fr.shikkanime.entities.enums.EpisodeType
 import fr.shikkanime.entities.enums.Platform
@@ -58,6 +59,19 @@ abstract class AbstractPlatform<C : PlatformConfiguration<*>, K : Any, V> {
         return apiCache.entries.firstOrNull { it.key.first == key }!!.value
     }
 
+    protected fun parseAPIContent(
+        bypassFileContent: File?,
+        key: K,
+        arrayKey: String,
+        zonedDateTime: ZonedDateTime
+    ): List<JsonObject> {
+        return if (bypassFileContent != null && bypassFileContent.exists()) {
+            ObjectParser.fromJson(bypassFileContent.readText()).getAsJsonArray(arrayKey).map { it.asJsonObject }
+        } else {
+            getApiContent(key, zonedDateTime) as List<JsonObject> // NOSONAR
+        }
+    }
+
     fun loadConfiguration(): C {
         val defaultValue = getConfigurationClass().getConstructor().newInstance()
         val file = getConfigurationFile()

src/main/kotlin/fr/shikkanime/platforms/AnimationDigitalNetworkPlatform.kt

@@ -12,7 +12,6 @@ import fr.shikkanime.exceptions.AnimeException
 import fr.shikkanime.exceptions.AnimeNotSimulcastedException
 import fr.shikkanime.platforms.configuration.AnimationDigitalNetworkConfiguration
 import fr.shikkanime.services.caches.ConfigCacheService
-import fr.shikkanime.utils.ObjectParser
 import fr.shikkanime.utils.ObjectParser.getAsBoolean
 import fr.shikkanime.utils.ObjectParser.getAsInt
 import fr.shikkanime.utils.ObjectParser.getAsLong
@@ -35,24 +34,11 @@ class AnimationDigitalNetworkPlatform :
         return AnimationDigitalNetworkWrapper.getLatestVideos(zonedDateTime.toLocalDate())
     }
 
-    private fun parseAPIContent(
-        bypassFileContent: File?,
-        countryCode: CountryCode,
-        zonedDateTime: ZonedDateTime
-    ): List<JsonObject> {
-        return if (bypassFileContent != null && bypassFileContent.exists()) {
-            ObjectParser.fromJson(bypassFileContent.readText()).getAsJsonArray("videos").map { it.asJsonObject }
-        } else getApiContent(
-            countryCode,
-            zonedDateTime
-        )
-    }
-
     override fun fetchEpisodes(zonedDateTime: ZonedDateTime, bypassFileContent: File?): List<Episode> {
         val list = mutableListOf<Episode>()
 
         configuration!!.availableCountries.forEach { countryCode ->
-            val api = parseAPIContent(bypassFileContent, countryCode, zonedDateTime)
+            val api = parseAPIContent(bypassFileContent, countryCode, "videos", zonedDateTime)
 
             api.forEach {
                 try {

src/main/kotlin/fr/shikkanime/platforms/CrunchyrollPlatform.kt

@@ -12,7 +12,6 @@ import fr.shikkanime.platforms.configuration.CrunchyrollConfiguration
 import fr.shikkanime.services.caches.ConfigCacheService
 import fr.shikkanime.utils.Constant
 import fr.shikkanime.utils.MapCache
-import fr.shikkanime.utils.ObjectParser
 import fr.shikkanime.utils.ObjectParser.getAsBoolean
 import fr.shikkanime.utils.ObjectParser.getAsInt
 import fr.shikkanime.utils.ObjectParser.getAsLong
@@ -111,24 +110,11 @@ class CrunchyrollPlatform : AbstractPlatform<CrunchyrollConfiguration, CountryCo
         )
     }
 
-    private fun parseAPIContent(
-        bypassFileContent: File?,
-        countryCode: CountryCode,
-        zonedDateTime: ZonedDateTime
-    ): List<JsonObject> {
-        return if (bypassFileContent != null && bypassFileContent.exists()) {
-            ObjectParser.fromJson(bypassFileContent.readText()).getAsJsonArray("data").map { it.asJsonObject }
-        } else getApiContent(
-            countryCode,
-            zonedDateTime
-        )
-    }
-
     override fun fetchEpisodes(zonedDateTime: ZonedDateTime, bypassFileContent: File?): List<Episode> {
         val list = mutableListOf<Episode>()
 
         configuration!!.availableCountries.forEach { countryCode ->
-            val api = parseAPIContent(bypassFileContent, countryCode, zonedDateTime)
+            val api = parseAPIContent(bypassFileContent, countryCode, "data", zonedDateTime)
 
             api.forEach {
                 try {

src/main/kotlin/fr/shikkanime/services/AnimeService.kt

@@ -160,9 +160,19 @@ class AnimeService : AbstractService<Anime, AnimeRepository>() {
             addBanner(anime.uuid, anime.banner)
         }
 
-        if (!animeDto.description.isNullOrBlank() && animeDto.description != anime.description) anime.description =
-            animeDto.description
+        if (!animeDto.description.isNullOrBlank() && animeDto.description != anime.description) {
+            anime.description = animeDto.description
+        }
+
+        updateAnimeSimulcast(animeDto, anime)
 
+        anime.status = StringUtils.getStatus(anime)
+        val update = super.update(anime)
+        MapCache.invalidate(Anime::class.java)
+        return update
+    }
+
+    private fun updateAnimeSimulcast(animeDto: AnimeDto, anime: Anime) {
         if (animeDto.simulcasts != null) {
             anime.simulcasts.clear()
 
@@ -174,11 +184,6 @@ class AnimeService : AbstractService<Anime, AnimeRepository>() {
                 }
             }
         }
-
-        anime.status = StringUtils.getStatus(anime)
-        val update = super.update(anime)
-        MapCache.invalidate(Anime::class.java)
-        return update
     }
 
     override fun delete(entity: Anime) {

src/main/kotlin/fr/shikkanime/services/EpisodeMappingService.kt

@@ -58,40 +58,8 @@ class EpisodeMappingService : AbstractService<EpisodeMapping, EpisodeMappingRepo
     fun update(uuid: UUID, entity: EpisodeMappingDto): EpisodeMapping? {
         val episode = find(uuid) ?: return null
 
-        if (entity.anime.name.isNotBlank() && entity.anime.name != episode.anime!!.name) {
-            val oldAnimeId = episode.anime!!.uuid!!
-            val findByName = requireNotNull(
-                animeService.findByName(
-                    episode.anime!!.countryCode!!,
-                    entity.anime.name
-                )
-            ) { "Anime with name ${entity.anime.name} not found" }
-            episode.anime = findByName
-            update(episode)
-
-            if (episode.title.isNullOrBlank()) {
-                episode.title = findByName.name
-            }
-
-            val oldAnime = animeService.find(oldAnimeId)!!
-
-            if (oldAnime.mappings.isEmpty()) {
-                animeService.delete(oldAnime)
-                MapCache.invalidate(Anime::class.java)
-            }
-        }
-
-        if (entity.releaseDateTime.isNotBlank() && entity.releaseDateTime != episode.releaseDateTime.toString()) {
-            episode.releaseDateTime = ZonedDateTime.parse(entity.releaseDateTime)
-        }
-
-        if (entity.lastReleaseDateTime.isNotBlank() && entity.lastReleaseDateTime != episode.lastReleaseDateTime.toString()) {
-            episode.lastReleaseDateTime = ZonedDateTime.parse(entity.lastReleaseDateTime)
-        }
-
-        if (entity.lastUpdateDateTime.isNotBlank() && entity.lastUpdateDateTime != episode.lastUpdateDateTime.toString()) {
-            episode.lastUpdateDateTime = ZonedDateTime.parse(entity.lastUpdateDateTime)
-        }
+        updateEpisodeMappingAnime(entity, episode)
+        updateEpisodeMappingDateTime(entity, episode)
 
         if (entity.episodeType != episode.episodeType) {
             episode.episodeType = entity.episodeType
@@ -127,6 +95,58 @@ class EpisodeMappingService : AbstractService<EpisodeMapping, EpisodeMappingRepo
         episode.lastUpdateDateTime = ZonedDateTime.now()
         var update = super.update(episode)
 
+        update = updateEpisodeMappingVariants(entity, episode, update, uuid)
+
+        MapCache.invalidate(EpisodeMapping::class.java)
+        return update
+    }
+
+    private fun updateEpisodeMappingAnime(entity: EpisodeMappingDto, episode: EpisodeMapping) {
+        if (entity.anime.name.isNotBlank() && entity.anime.name != episode.anime!!.name) {
+            val oldAnimeId = episode.anime!!.uuid!!
+            val findByName = requireNotNull(
+                animeService.findByName(
+                    episode.anime!!.countryCode!!,
+                    entity.anime.name
+                )
+            ) { "Anime with name ${entity.anime.name} not found" }
+            episode.anime = findByName
+            update(episode)
+
+            if (episode.title.isNullOrBlank()) {
+                episode.title = findByName.name
+            }
+
+            val oldAnime = animeService.find(oldAnimeId)!!
+
+            if (oldAnime.mappings.isEmpty()) {
+                animeService.delete(oldAnime)
+                MapCache.invalidate(Anime::class.java)
+            }
+        }
+    }
+
+    private fun updateEpisodeMappingDateTime(entity: EpisodeMappingDto, episode: EpisodeMapping) {
+        if (entity.releaseDateTime.isNotBlank() && entity.releaseDateTime != episode.releaseDateTime.toString()) {
+            episode.releaseDateTime = ZonedDateTime.parse(entity.releaseDateTime)
+        }
+
+        if (entity.lastReleaseDateTime.isNotBlank() && entity.lastReleaseDateTime != episode.lastReleaseDateTime.toString()) {
+            episode.lastReleaseDateTime = ZonedDateTime.parse(entity.lastReleaseDateTime)
+        }
+
+        if (entity.lastUpdateDateTime.isNotBlank() && entity.lastUpdateDateTime != episode.lastUpdateDateTime.toString()) {
+            episode.lastUpdateDateTime = ZonedDateTime.parse(entity.lastUpdateDateTime)
+        }
+    }
+
+    private fun updateEpisodeMappingVariants(
+        entity: EpisodeMappingDto,
+        episode: EpisodeMapping,
+        update: EpisodeMapping,
+        uuid: UUID
+    ): EpisodeMapping {
+        var update1 = update
         if (!entity.variants.isNullOrEmpty()) {
             val oldList = mutableSetOf(*episode.variants.toTypedArray())
             episode.variants.clear()
@@ -139,11 +159,9 @@ class EpisodeMappingService : AbstractService<EpisodeMapping, EpisodeMappingRepo
 
             oldList.forEach { episodeVariantRepository.delete(it) }
             MapCache.invalidate(EpisodeVariant::class.java)
-            update = find(uuid)!!
+            update1 = find(uuid)!!
         }
-
-        MapCache.invalidate(EpisodeMapping::class.java)
-        return update
+        return update1
     }
 
     override fun delete(entity: EpisodeMapping) {

src/main/resources/assets/css/main.css

@@ -30,9 +30,10 @@ body {
     color: #b9b9b9 !important;
 }
 
-.card {
-    border: 1px solid #FFFFFF14 !important;
-    background-color: #FFFFFF14 !important;
+.shikk-element {
+    border: 1px solid #FFFFFF14;
+    border-radius: 1rem;
+    background-color: #FFFFFF14;
 }
 
 .bg-blur {

src/main/resources/purge.sh

@@ -1,21 +1,21 @@
 #!/bin/bash
-PURGE_PATH="./assets/css/purged"
+CSS_PURGED_PATH="./assets/css/purged"
 
 echo "Purging and minifying css..."
 
 echo "Removing old purged css..."
-rm -rf $PURGE_PATH
+rm -rf $CSS_PURGED_PATH
 echo "Creating new purged css directory..."
-mkdir -p $PURGE_PATH
+mkdir -p $CSS_PURGED_PATH
 echo "Purging css..."
 purgecss --config ./purgecss.config.js
 
 # Minify the purged css
 echo "Minifying purged css..."
-minify $PURGE_PATH/main.css > $PURGE_PATH/main.min.css
+minify $CSS_PURGED_PATH/main.css > $CSS_PURGED_PATH/main.min.css
 
 # Remove the purged css
 echo "Removing purged css not minified..."
-rm $PURGE_PATH/main.css
+rm $CSS_PURGED_PATH/main.css
 
 echo "Done!"

src/main/resources/templates/_freemarker_implicit.ftl

@@ -18,7 +18,6 @@
 [#-- @ftlvariable name="currentSimulcast" type="fr.shikkanime.dtos.SimulcastDto" --]
 [#-- @ftlvariable name="footerLinks" type="kotlin.collections.AbstractList<fr.shikkanime.entities.LinkObject>" --]
 [#-- @ftlvariable name="seoLinks" type="kotlin.collections.AbstractList<fr.shikkanime.entities.enums.Link>" --]
-[#-- @ftlvariable name="query" type="java.lang.String" --]
 [#-- @ftlvariable name="su" type="fr.shikkanime.utils.StringUtils" --]
 [#-- @ftlvariable name="weeklyAnimes" type="kotlin.collections.AbstractList<fr.shikkanime.dtos.WeeklyAnimesDto>" --]
 

src/main/resources/templates/site/_layout.ftl

@@ -65,6 +65,7 @@
     <#nested 0>
 
     <script src="/assets/js/bootstrap.bundle.min.js" crossorigin="anonymous"></script>
+    <script src="/assets/js/main.js" crossorigin="anonymous"></script>
     </body>
     </html>
 </#macro>