Cleanup: Update function signatures, mapping implementation after tab…

…le changes.
thomaskioko · Nov 19, 2023 · 050ac0d · 050ac0d
1 parent 374c4d4
commit 050ac0d
Show file tree

Hide file tree

Showing 58 changed files with 348 additions and 399 deletions.
diff --git a/android-features/shows-grid/src/main/kotlin/com/thomaskioko/tvmaniac/showsgrid/Mapper.kt b/android-features/shows-grid/src/main/kotlin/com/thomaskioko/tvmaniac/showsgrid/Mapper.kt
@@ -3,10 +3,8 @@ package com.thomaskioko.tvmaniac.showsgrid
 import com.thomaskioko.tvmaniac.core.db.ShowsByCategory
 import com.thomaskioko.tvmaniac.showsgrid.model.TvShow
 
-fun List<ShowsByCategory>.toTvShowList(): List<TvShow> = map { it.toTvShow() }
-
 fun ShowsByCategory.toTvShow(): TvShow = TvShow(
-    traktId = trakt_id,
+    traktId = id.id,
     tmdbId = tmdb_id,
     title = title,
     posterImageUrl = poster_url,

diff --git a/...ry/api/src/commonMain/kotlin/com/thomaskioko/tvmaniac/category/api/cache/CategoryCache.kt b/...ry/api/src/commonMain/kotlin/com/thomaskioko/tvmaniac/category/api/cache/CategoryCache.kt
@@ -3,6 +3,6 @@ package com.thomaskioko.tvmaniac.category.api.cache
 import com.thomaskioko.tvmaniac.core.db.Show_category
 
 interface CategoryCache {
-    fun insert(category: Show_category)
-    fun insert(category: List<Show_category>)
+    fun upsert(category: Show_category)
+    fun upsert(category: List<Show_category>)
 }
diff --git a/...monMain/kotlin/com/thomaskioko/tvmaniac/data/category/implementation/CategoryCacheImpl.kt b/...monMain/kotlin/com/thomaskioko/tvmaniac/data/category/implementation/CategoryCacheImpl.kt
@@ -12,16 +12,16 @@ class CategoryCacheImpl(
 
     private val showCategoryQuery get() = database.show_categoryQueries
 
-    override fun insert(category: Show_category) {
+    override fun upsert(category: Show_category) {
         database.transaction {
             showCategoryQuery.insertOrReplace(
-                trakt_id = category.trakt_id,
+                id = category.id,
                 category_id = category.category_id,
             )
         }
     }
 
-    override fun insert(category: List<Show_category>) {
-        category.forEach { insert(it) }
+    override fun upsert(category: List<Show_category>) {
+        category.forEach { upsert(it) }
     }
 }
diff --git a/...s/api/src/commonMain/kotlin/com/thomaskioko/tvmaniac/episodeimages/api/EpisodeImageDao.kt b/...s/api/src/commonMain/kotlin/com/thomaskioko/tvmaniac/episodeimages/api/EpisodeImageDao.kt
@@ -6,9 +6,9 @@ import kotlinx.coroutines.flow.Flow
 
 interface EpisodeImageDao {
 
-    fun insert(entity: Episode_image)
+    fun upsert(entity: Episode_image)
 
-    fun insert(list: List<Episode_image>)
+    fun upsert(list: List<Episode_image>)
 
     fun observeEpisodeImage(): Flow<List<EpisodeImage>>
 }
diff --git a/...nMain/kotlin/com/thomaskioko/tvmaniac/episodeimages/implementation/EpisodeImageDaoImpl.kt b/...nMain/kotlin/com/thomaskioko/tvmaniac/episodeimages/implementation/EpisodeImageDaoImpl.kt
@@ -18,17 +18,17 @@ class EpisodeImageDaoImpl(
 
     private val episodeQueries get() = database.episode_imageQueries
 
-    override fun insert(entity: Episode_image) {
+    override fun upsert(entity: Episode_image) {
         episodeQueries.insertOrReplace(
-            trakt_id = entity.trakt_id,
+            id = entity.id,
             tmdb_id = entity.tmdb_id,
             image_url = entity.image_url,
         )
     }
 
-    override fun insert(list: List<Episode_image>) {
+    override fun upsert(list: List<Episode_image>) {
         database.transaction {
-            list.map { insert(it) }
+            list.map { upsert(it) }
         }
     }
 

diff --git a/...otlin/com/thomaskioko/tvmaniac/episodeimages/implementation/EpisodeImageRepositoryImpl.kt b/...otlin/com/thomaskioko/tvmaniac/episodeimages/implementation/EpisodeImageRepositoryImpl.kt
@@ -6,6 +6,7 @@ import com.thomaskioko.tvmaniac.core.networkutil.DefaultError
 import com.thomaskioko.tvmaniac.core.networkutil.Either
 import com.thomaskioko.tvmaniac.core.networkutil.Failure
 import com.thomaskioko.tvmaniac.core.networkutil.NetworkExceptionHandler
+import com.thomaskioko.tvmaniac.db.Id
 import com.thomaskioko.tvmaniac.episodeimages.api.EpisodeImageDao
 import com.thomaskioko.tvmaniac.episodeimages.api.EpisodeImageRepository
 import com.thomaskioko.tvmaniac.tmdb.api.TmdbNetworkDataSource
@@ -38,10 +39,10 @@ class EpisodeImageRepositoryImpl(
 
                         when (response) {
                             is ApiResponse.Success -> {
-                                episodeImageDao.insert(
+                                episodeImageDao.upsert(
                                     Episode_image(
-                                        trakt_id = episodeArt.trakt_id,
-                                        tmdb_id = response.body.id.toLong(),
+                                        id = Id(id = response.body.id.toLong()),
+                                        tmdb_id = Id(id = tmdbId),
                                         image_url = response.body.imageUrl?.let {
                                             formatterUtil.formatTmdbPosterPath(it)
                                         },

diff --git a/data/episodes/api/src/commonMain/kotlin/com/thomaskioko/tvmaniac/episodes/api/EpisodesDao.kt b/data/episodes/api/src/commonMain/kotlin/com/thomaskioko/tvmaniac/episodes/api/EpisodesDao.kt
@@ -1,6 +1,6 @@
 package com.thomaskioko.tvmaniac.episodes.api
 
-import com.thomaskioko.tvmaniac.core.db.Episodes as EpisodeCache
+import com.thomaskioko.tvmaniac.core.db.Episode as EpisodeCache
 
 interface EpisodesDao {
 

diff --git a/...src/commonMain/kotlin/com/thomaskioko/tvmaniac/episodes/implementation/EpisodesDaoImpl.kt b/...src/commonMain/kotlin/com/thomaskioko/tvmaniac/episodes/implementation/EpisodesDaoImpl.kt
@@ -1,9 +1,10 @@
 package com.thomaskioko.tvmaniac.episodes.implementation
 
 import com.thomaskioko.tvmaniac.core.db.TvManiacDatabase
+import com.thomaskioko.tvmaniac.db.Id
 import com.thomaskioko.tvmaniac.episodes.api.EpisodesDao
 import me.tatarka.inject.annotations.Inject
-import com.thomaskioko.tvmaniac.core.db.Episodes as EpisodeCache
+import com.thomaskioko.tvmaniac.core.db.Episode as EpisodeCache
 
 @Inject
 class EpisodesDaoImpl(
@@ -15,7 +16,7 @@ class EpisodesDaoImpl(
     override fun insert(entity: EpisodeCache) {
         database.transaction {
             episodeQueries.insertOrReplace(
-                trakt_id = entity.trakt_id,
+                id = entity.id,
                 season_id = entity.season_id,
                 tmdb_id = entity.tmdb_id,
                 title = entity.title,
@@ -33,7 +34,7 @@ class EpisodesDaoImpl(
     }
 
     override fun delete(id: Long) {
-        episodeQueries.delete(id)
+        episodeQueries.delete(Id(id))
     }
 
     override fun deleteAll() {

diff --git a/.../src/commonMain/kotlin/com/thomaskioko/tvmaniac/profilestats/implementation/StatsStore.kt b/.../src/commonMain/kotlin/com/thomaskioko/tvmaniac/profilestats/implementation/StatsStore.kt
@@ -22,7 +22,7 @@ class StatsStore(
     private val mapper: StatsMapper,
     private val logger: KermitLogger,
     private val scope: AppCoroutineScope,
-) : Store<String, Stats> by storeBuilderFromFetcherAndSourceOfTruth<String, Stats, Stats>(
+) : Store<String, Stats> by storeBuilderFromFetcherAndSourceOfTruth(
     fetcher = Fetcher.of { slug ->
 
         when (val response = remoteDataSource.getStats(slug)) {

diff --git a/...c/commonMain/kotlin/com/thomaskioko/tvmaniac/seasondetails/api/SeasonDetailsRepository.kt b/...c/commonMain/kotlin/com/thomaskioko/tvmaniac/seasondetails/api/SeasonDetailsRepository.kt
@@ -1,13 +1,13 @@
 package com.thomaskioko.tvmaniac.seasondetails.api
 
-import com.thomaskioko.tvmaniac.core.db.SeasonWithEpisodes
+import com.thomaskioko.tvmaniac.core.db.SeasonEpisodeDetailsById
 import com.thomaskioko.tvmaniac.core.networkutil.Either
 import com.thomaskioko.tvmaniac.core.networkutil.Failure
 import kotlinx.coroutines.flow.Flow
 
 interface SeasonDetailsRepository {
 
-    fun observeSeasonDetailsStream(traktId: Long): Flow<Either<Failure, List<SeasonWithEpisodes>>>
+    suspend fun fetchSeasonDetails(traktId: Long): List<SeasonEpisodeDetailsById>
 
-    fun observeCachedSeasonDetails(traktId: Long): Flow<Either<Failure, List<SeasonWithEpisodes>>>
+    fun observeSeasonDetailsStream(traktId: Long): Flow<Either<Failure, List<SeasonEpisodeDetailsById>>>
 }
diff --git a/...ion/src/commonMain/kotlin/com/thomaskioko/tvmaniac/seasondetails/implementation/Mapper.kt b/...ion/src/commonMain/kotlin/com/thomaskioko/tvmaniac/seasondetails/implementation/Mapper.kt
@@ -1,31 +1,27 @@
 package com.thomaskioko.tvmaniac.seasondetails.implementation
 
-import com.thomaskioko.tvmaniac.core.db.Episodes
-import com.thomaskioko.tvmaniac.core.db.SeasonWithEpisodes
-import com.thomaskioko.tvmaniac.trakt.api.model.TraktEpisodesResponse
+import com.thomaskioko.tvmaniac.core.db.Episode
+import com.thomaskioko.tvmaniac.db.Id
 import com.thomaskioko.tvmaniac.trakt.api.model.TraktSeasonEpisodesResponse
 
-fun TraktSeasonEpisodesResponse.toEpisodeCacheList(): List<Episodes> {
-    return episodes.map { episodeResponse ->
-        Episodes(
-            season_id = ids.trakt.toLong(),
-            trakt_id = episodeResponse.ids.trakt.toLong(),
-            tmdb_id = episodeResponse.ids.tmdb?.toLong(),
-            title = episodeResponse.title,
-            overview = episodeResponse.overview ?: "TBA",
-            ratings = episodeResponse.ratings,
-            runtime = episodeResponse.runtime.toLong(),
-            votes = episodeResponse.votes.toLong(),
-            episode_number = episodeResponse.episodeNumber.toString().padStart(2, '0'),
+internal fun List<TraktSeasonEpisodesResponse>.toSeasonWithEpisodes(): List<SeasonData> {
+    return map { season ->
+        SeasonData(
+            seasonId = season.ids.trakt.toLong(),
+            title = season.title,
+            overview = season.overview ?: "TBA",
+            episodeCount = season.episodeCount.toLong(),
+            seasonNumber = season.number.toLong(),
+            episodes = season.toEpisodeCacheList(),
         )
     }
 }
 
-fun List<TraktEpisodesResponse>.toEpisodeCache(seasonId: Long): List<Episodes> {
-    return map { episodeResponse ->
-        Episodes(
-            season_id = seasonId,
-            trakt_id = episodeResponse.ids.trakt.toLong(),
+fun TraktSeasonEpisodesResponse.toEpisodeCacheList(): List<Episode> {
+    return episodes.map { episodeResponse ->
+        Episode(
+            id = Id(episodeResponse.ids.trakt.toLong()),
+            season_id = Id(ids.trakt.toLong()),
             tmdb_id = episodeResponse.ids.tmdb?.toLong(),
             title = episodeResponse.title,
             overview = episodeResponse.overview ?: "TBA",
@@ -37,7 +33,11 @@ fun List<TraktEpisodesResponse>.toEpisodeCache(seasonId: Long): List<Episodes> {
     }
 }
 
-fun List<TraktSeasonEpisodesResponse>.toSeasonWithEpisodes(): List<SeasonWithEpisodes> {
-    // TODO:: Add mapping #59
-    return emptyList()
-}
+internal data class SeasonData(
+    val seasonId: Long,
+    val title: String,
+    val overview: String,
+    val seasonNumber: Long,
+    val episodeCount: Long,
+    val episodes: List<Episode>,
+)
diff --git a/...in/kotlin/com/thomaskioko/tvmaniac/seasondetails/implementation/SeasonDetailsComponent.kt b/...in/kotlin/com/thomaskioko/tvmaniac/seasondetails/implementation/SeasonDetailsComponent.kt
@@ -1,6 +1,5 @@
 package com.thomaskioko.tvmaniac.seasondetails.implementation
 
-import com.thomaskioko.tvmaniac.seasondetails.api.SeasonDetailsDao
 import com.thomaskioko.tvmaniac.seasondetails.api.SeasonDetailsRepository
 import com.thomaskioko.tvmaniac.util.scope.ApplicationScope
 import me.tatarka.inject.annotations.Provides
@@ -12,8 +11,4 @@ interface SeasonDetailsComponent {
     fun provideSeasonDetailsRepository(
         bind: SeasonDetailsRepositoryImpl,
     ): SeasonDetailsRepository = bind
-
-    @ApplicationScope
-    @Provides
-    fun provideSeasonsDetailsDao(bind: SeasonDetailsDaoImpl): SeasonDetailsDao = bind
 }
diff --git a/...tlin/com/thomaskioko/tvmaniac/seasondetails/implementation/SeasonDetailsRepositoryImpl.kt b/...tlin/com/thomaskioko/tvmaniac/seasondetails/implementation/SeasonDetailsRepositoryImpl.kt
@@ -1,50 +1,46 @@
 package com.thomaskioko.tvmaniac.seasondetails.implementation
 
-import com.thomaskioko.tvmaniac.core.db.SeasonWithEpisodes
-import com.thomaskioko.tvmaniac.core.db.Season_episodes
+import com.thomaskioko.tvmaniac.core.db.Season
+import com.thomaskioko.tvmaniac.core.db.SeasonEpisodeDetailsById
 import com.thomaskioko.tvmaniac.core.networkutil.ApiResponse
-import com.thomaskioko.tvmaniac.core.networkutil.DefaultError
 import com.thomaskioko.tvmaniac.core.networkutil.Either
 import com.thomaskioko.tvmaniac.core.networkutil.Failure
 import com.thomaskioko.tvmaniac.core.networkutil.NetworkExceptionHandler
 import com.thomaskioko.tvmaniac.core.networkutil.networkBoundResult
+import com.thomaskioko.tvmaniac.db.Id
 import com.thomaskioko.tvmaniac.episodes.api.EpisodesDao
-import com.thomaskioko.tvmaniac.seasondetails.api.SeasonDetailsDao
 import com.thomaskioko.tvmaniac.seasondetails.api.SeasonDetailsRepository
+import com.thomaskioko.tvmaniac.seasons.api.SeasonsDao
 import com.thomaskioko.tvmaniac.trakt.api.TraktShowsRemoteDataSource
 import com.thomaskioko.tvmaniac.trakt.api.model.ErrorResponse
 import com.thomaskioko.tvmaniac.trakt.api.model.TraktSeasonEpisodesResponse
 import com.thomaskioko.tvmaniac.util.KermitLogger
 import com.thomaskioko.tvmaniac.util.model.AppCoroutineDispatchers
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.catch
-import kotlinx.coroutines.flow.map
 import me.tatarka.inject.annotations.Inject
 
 @Inject
 class SeasonDetailsRepositoryImpl(
     private val remoteDataSource: TraktShowsRemoteDataSource,
-    private val seasonCache: SeasonDetailsDao,
+    private val seasonCache: SeasonsDao,
     private val episodesDao: EpisodesDao,
     private val exceptionHandler: NetworkExceptionHandler,
     private val dispatcher: AppCoroutineDispatchers,
     private val logger: KermitLogger,
 ) : SeasonDetailsRepository {
 
-    override fun observeSeasonDetailsStream(traktId: Long): Flow<Either<Failure, List<SeasonWithEpisodes>>> =
+    override fun observeSeasonDetailsStream(traktId: Long): Flow<Either<Failure, List<SeasonEpisodeDetailsById>>> =
         networkBoundResult(
-            query = { seasonCache.observeShowEpisodes(traktId) },
+            query = { seasonCache.observeSeasonEpisodeDetailsById(traktId) },
             shouldFetch = { it.isNullOrEmpty() },
             fetch = { remoteDataSource.getSeasonEpisodes(traktId) },
             saveFetchResult = { mapResponse(traktId, it) },
             exceptionHandler = exceptionHandler,
             coroutineDispatcher = dispatcher.io,
         )
 
-    override fun observeCachedSeasonDetails(traktId: Long): Flow<Either<Failure, List<SeasonWithEpisodes>>> =
-        seasonCache.observeShowEpisodes(traktId)
-            .catch { Either.Left(DefaultError(exceptionHandler.resolveError(it))) }
-            .map { Either.Right(it) }
+    override suspend fun fetchSeasonDetails(traktId: Long): List<SeasonEpisodeDetailsById> =
+        seasonCache.fetchSeasonDetails(traktId)
 
     private fun mapResponse(
         showId: Long,
@@ -55,11 +51,14 @@ class SeasonDetailsRepositoryImpl(
                 response.body.forEach { season ->
                     episodesDao.insert(season.toEpisodeCacheList())
 
-                    seasonCache.insert(
-                        Season_episodes(
-                            show_id = showId,
-                            season_id = season.ids.trakt.toLong(),
+                    seasonCache.upsert(
+                        Season(
+                            id = Id(season.ids.trakt.toLong()),
+                            show_id = Id(showId),
                             season_number = season.number.toLong(),
+                            title = season.title,
+                            episode_count = season.episodeCount.toLong(),
+                            overview = season.overview,
                         ),
                     )
                 }

diff --git a/...onMain/kotlin/com/thomaskioko/tvmaniac/seasondetails/implementation/SeasonDetailsStore.kt b/...onMain/kotlin/com/thomaskioko/tvmaniac/seasondetails/implementation/SeasonDetailsStore.kt
@@ -1,11 +1,11 @@
 package com.thomaskioko.tvmaniac.seasondetails.implementation
 
-import com.thomaskioko.tvmaniac.core.db.Episodes
-import com.thomaskioko.tvmaniac.core.db.SeasonWithEpisodes
-import com.thomaskioko.tvmaniac.core.db.Season_episodes
+import com.thomaskioko.tvmaniac.core.db.Season
+import com.thomaskioko.tvmaniac.core.db.SeasonEpisodeDetailsById
 import com.thomaskioko.tvmaniac.core.networkutil.ApiResponse
+import com.thomaskioko.tvmaniac.db.Id
 import com.thomaskioko.tvmaniac.episodes.api.EpisodesDao
-import com.thomaskioko.tvmaniac.seasondetails.api.SeasonDetailsDao
+import com.thomaskioko.tvmaniac.seasons.api.SeasonsDao
 import com.thomaskioko.tvmaniac.trakt.api.TraktShowsRemoteDataSource
 import com.thomaskioko.tvmaniac.util.KermitLogger
 import com.thomaskioko.tvmaniac.util.model.AppCoroutineScope
@@ -18,12 +18,12 @@ import org.mobilenativefoundation.store.store5.StoreBuilder
 @Inject
 class SeasonDetailsStore(
     private val remoteDataSource: TraktShowsRemoteDataSource,
-    private val seasonDetailsDao: SeasonDetailsDao,
+    private val seasonCache: SeasonsDao,
     private val episodesDao: EpisodesDao,
     private val scope: AppCoroutineScope,
     private val logger: KermitLogger,
-) : Store<Long, List<SeasonWithEpisodes>> by StoreBuilder
-    .from<Long, List<SeasonWithEpisodes>, List<SeasonWithEpisodes>>(
+) : Store<Long, List<SeasonEpisodeDetailsById>> by StoreBuilder
+    .from(
         fetcher = Fetcher.of { id: Long ->
             when (val response = remoteDataSource.getSeasonEpisodes(id)) {
                 is ApiResponse.Success -> response.body.toSeasonWithEpisodes()
@@ -44,34 +44,25 @@ class SeasonDetailsStore(
             }
         },
         sourceOfTruth = SourceOfTruth.of(
-            reader = seasonDetailsDao::observeShowEpisodes,
+            reader = seasonCache::observeSeasonEpisodeDetailsById,
             writer = { id, list ->
                 list.forEach { season ->
-                    episodesDao.insert(
-                        Episodes(
-                            trakt_id = season.trakt_id,
-                            season_id = season.season_id,
+                    seasonCache.upsert(
+                        Season(
+                            id = Id(season.seasonId),
+                            show_id = Id(id),
+                            season_number = season.seasonNumber,
                             title = season.title,
-                            tmdb_id = season.tmdb_id,
+                            episode_count = season.episodeCount,
                             overview = season.overview,
-                            ratings = season.ratings,
-                            runtime = season.runtime,
-                            votes = season.votes,
-                            episode_number = season.episode_number,
                         ),
                     )
 
-                    seasonDetailsDao.insert(
-                        Season_episodes(
-                            show_id = id,
-                            season_id = season.trakt_id,
-                            season_number = season.season_number,
-                        ),
-                    )
+                    episodesDao.insert(season.episodes)
                 }
             },
-            delete = seasonDetailsDao::delete,
-            deleteAll = seasonDetailsDao::deleteAll,
+            delete = seasonCache::delete,
+            deleteAll = seasonCache::deleteAll,
         ),
     )
     .scope(scope.io)