dev

.github/workflows/build_linux.yml

@@ -27,6 +27,11 @@ jobs:
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
 
+      - name: set up LOCAL_PROPERTIES
+        env:
+          LOCAL_PROPERTIES: ${{ secrets.LOCAL_PROPERTIES }}
+        run: echo "$LOCAL_PROPERTIES" > ./local.properties
+
       - name: Build with Gradle
         run: ./gradlew assembleAndroidTest
 
@@ -49,5 +54,10 @@ jobs:
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
 
+      - name: set up LOCAL_PROPERTIES
+        env:
+          LOCAL_PROPERTIES: ${{ secrets.LOCAL_PROPERTIES }}
+        run: echo "$LOCAL_PROPERTIES" > ./local.properties
+
       - name: Build with Gradle
         run: ./gradlew desktopMainClasses desktopSourcesJar desktopTestClasses

.github/workflows/build_mac_os.yml

@@ -30,5 +30,10 @@ jobs:
         with:
           xcode-version: latest-stable
 
+      - name: set up LOCAL_PROPERTIES
+        env:
+          LOCAL_PROPERTIES: ${{ secrets.LOCAL_PROPERTIES }}
+        run: echo "$LOCAL_PROPERTIES" > ./local.properties
+
       - name: Build with Gradle
         run: ./gradlew iosArm64Binaries

composeApp/src/commonMain/kotlin/App.kt

@@ -1,12 +1,12 @@
 import androidx.compose.runtime.Composable
 import com.stslex.core.core.coreModule
-import com.stslex.core.database.di.databaseModule
-import com.stslex.core.network.di.networkModule
+import com.stslex.core.database.di.coreDatabaseModule
+import com.stslex.core.network.di.coreNetworkModule
 import com.stslex.core.ui.theme.AppTheme
-import com.stslex.feature.film.di.filmModule
-import com.stslex.feature.film_feed.di.feedModule
-import com.stslex.feature.match_feed.di.matchFeedModule
-import com.stslex.feature.profile.di.profileModule
+import com.stslex.feature.film.di.featureFilmModule
+import com.stslex.feature.film_feed.di.featureFeedModule
+import com.stslex.feature.match_feed.di.featureMatchFeedModule
+import com.stslex.feature.profile.di.featureProfileModule
 import di.appModule
 import org.koin.compose.KoinApplication
 import org.koin.dsl.KoinAppDeclaration
@@ -35,12 +35,12 @@ private fun setupModules(): KoinAppDeclaration = {
         listOf(
             appModule,
             coreModule,
-            networkModule,
-            databaseModule,
-            feedModule,
-            filmModule,
-            profileModule,
-            matchFeedModule
+            coreNetworkModule,
+            coreDatabaseModule,
+            featureFeedModule,
+            featureFilmModule,
+            featureProfileModule,
+            featureMatchFeedModule
         )
     )
 }

core/database/src/commonMain/kotlin/com/stslex/core/database/di/DatabaseModel.kt

@@ -4,6 +4,6 @@ import com.stslex.core.database.sources.source.FavouriteFilmDataSource
 import com.stslex.core.database.sources.source.FavouriteFilmDataSourceImpl
 import org.koin.dsl.module
 
-val databaseModule = module {
+val coreDatabaseModule = module {
     single<FavouriteFilmDataSource> { FavouriteFilmDataSourceImpl() }
 }

core/network/build.gradle.kts

@@ -1,9 +1,13 @@
+import com.android.build.gradle.internal.cxx.configure.gradleLocalProperties
+import com.github.gmazzo.gradle.plugins.BuildConfigExtension
+
 plugins {
     alias(libs.plugins.kotlinMultiplatform)
     alias(libs.plugins.androidLibrary)
     alias(libs.plugins.jetbrainsCompose)
     alias(libs.plugins.kotlinCocoapods)
     kotlin("plugin.serialization") version "1.9.20"
+    id("com.github.gmazzo.buildconfig").version("4.2.0")
 }
 
 kotlin {
@@ -43,6 +47,9 @@ kotlin {
         commonTest.dependencies {
             implementation(libs.kotlin.test)
         }
+        buildConfig {
+            setLocalProperty(project.rootProject)
+        }
     }
 }
 
@@ -53,3 +60,11 @@ android {
         minSdk = libs.versions.android.minSdk.get().toInt()
     }
 }
+
+
+fun BuildConfigExtension.setLocalProperty(dir: Project) {
+    val key = gradleLocalProperties(dir.projectDir)["KINOPOISK_API_KEY"]
+        ?.toString()
+        ?: throw IllegalStateException("KINOPOISK_API_KEY should be initialised")
+    buildConfigField("String", "KINOPOISK_API_KEY", key)
+}

core/network/src/commonMain/kotlin/com/stslex/core/network/api/base/BaseNetworkClient.kt

@@ -0,0 +1,32 @@
+package com.stslex.core.network.api.base
+
+import com.stslex.core.core.AppDispatcher
+import com.stslex.core.network.api.model.DefaultRequest
+import com.stslex.core.network.api.base.NetworkClientBuilder.setupDefaultRequest
+import com.stslex.core.network.api.base.NetworkClientBuilder.setupLogging
+import com.stslex.core.network.api.base.NetworkClientBuilder.setupNegotiation
+import io.ktor.client.HttpClient
+import io.ktor.client.engine.cio.CIO
+import io.ktor.client.plugins.cache.HttpCache
+import kotlinx.coroutines.withContext
+
+abstract class BaseNetworkClient(
+    private val appDispatcher: AppDispatcher,
+    defaultRequest: DefaultRequest = DefaultRequest.EMPTY
+) : NetworkClient {
+
+    override suspend fun <T> request(
+        request: suspend HttpClient.() -> T
+    ): T = withContext(appDispatcher.io) {
+        request(client)
+    }
+
+    private val client: HttpClient = HttpClient(CIO) {
+        setupNegotiation()
+        install(HttpCache)
+        setupLogging()
+        expectSuccess = true
+        setupDefaultRequest(defaultRequest)
+    }
+}
+

core/network/src/commonMain/kotlin/com/stslex/core/network/api/base/DefaultNetworkClientImpl.kt

@@ -0,0 +1,7 @@
+package com.stslex.core.network.api.base
+
+import com.stslex.core.core.AppDispatcher
+
+class DefaultNetworkClientImpl(
+    dispatcher: AppDispatcher
+) : BaseNetworkClient(dispatcher)

core/network/src/commonMain/kotlin/com/stslex/core/network/client/NetworkClient.kt → core/network/src/commonMain/kotlin/com/stslex/core/network/api/base/NetworkClient.kt

@@ -1,4 +1,4 @@
-package com.stslex.core.network.client
+package com.stslex.core.network.api.base
 
 import io.ktor.client.HttpClient
 

core/network/src/commonMain/kotlin/com/stslex/core/network/client/NetworkClientBuilder.kt → core/network/src/commonMain/kotlin/com/stslex/core/network/api/base/NetworkClientBuilder.kt

@@ -1,5 +1,6 @@
-package com.stslex.core.network.client
+package com.stslex.core.network.api.base
 
+import com.stslex.core.network.api.model.DefaultRequest
 import com.stslex.core.network.utils.KtorLogger
 import io.ktor.client.HttpClientConfig
 import io.ktor.client.engine.cio.CIOEngineConfig
@@ -15,8 +16,6 @@ import kotlinx.serialization.json.Json
 
 internal object NetworkClientBuilder {
 
-    private const val HOST_URL = "smth_host_url"
-
     @OptIn(ExperimentalSerializationApi::class)
     fun HttpClientConfig<CIOEngineConfig>.setupNegotiation() {
         install(ContentNegotiation) {
@@ -31,14 +30,18 @@ internal object NetworkClientBuilder {
         }
     }
 
-    fun HttpClientConfig<CIOEngineConfig>.setupDefaultRequest() {
+    fun HttpClientConfig<CIOEngineConfig>.setupDefaultRequest(
+        defaultRequest: DefaultRequest
+    ) {
         defaultRequest {
             url {
-                host = HOST_URL
+                host = defaultRequest.hostUrl
                 protocol = URLProtocol.HTTPS
             }
             headers {
-                // TODO add auth headers
+                defaultRequest.headers.forEach { (key, value) ->
+                    append(key, value)
+                }
             }
         }
     }

core/network/src/commonMain/kotlin/com/stslex/core/network/api/kinopoisk/KinopoiskApiClient.kt

@@ -0,0 +1,3 @@
+package com.stslex.core.network.api.kinopoisk
+
+interface KinopoiskApiClient

core/network/src/commonMain/kotlin/com/stslex/core/network/api/kinopoisk/KinopoiskApiClientImpl.kt

@@ -0,0 +1,30 @@
+package com.stslex.core.network.api.kinopoisk
+
+import Wizard.core.network.BuildConfig
+import com.stslex.core.core.AppDispatcher
+import com.stslex.core.network.api.base.BaseNetworkClient
+import com.stslex.core.network.api.model.DefaultRequest
+
+class KinopoiskApiClientImpl(
+    appDispatcher: AppDispatcher
+) : KinopoiskApiClient, BaseNetworkClient(
+    appDispatcher = appDispatcher,
+    defaultRequest = DEFAULT_REQUEST
+) {
+
+    companion object {
+        private const val KINOPOISK_HOST_URL = "https://kinopoiskapiunofficial.tech/api/v2.2/"
+        private const val API_KEY = BuildConfig.KINOPOISK_API_KEY
+        private const val API_HEADER = "X-API-KEY"
+        private const val CONTENT_TYPE = "Content-Type"
+        private const val CONTENT_TYPE_VALUE = "application/json"
+
+        private val DEFAULT_REQUEST = DefaultRequest(
+            hostUrl = KINOPOISK_HOST_URL,
+            headers = mapOf(
+                API_HEADER to API_KEY,
+                CONTENT_TYPE to CONTENT_TYPE_VALUE
+            )
+        )
+    }
+}

core/network/src/commonMain/kotlin/com/stslex/core/network/api/kinopoisk/model/NetworkApiKinopoiskMapper.kt

@@ -0,0 +1,95 @@
+package com.stslex.core.network.api.kinopoisk.model
+
+import com.stslex.core.network.api.kinopoisk.model.network.FilmItemNetwork
+import com.stslex.core.network.api.kinopoisk.model.network.FilmListNetwork
+import com.stslex.core.network.api.kinopoisk.model.network.FilmProductionStatusNetwork
+import com.stslex.core.network.api.kinopoisk.model.network.FilmTypeNetwork
+import com.stslex.core.network.api.kinopoisk.model.network.MovieNetwork
+import com.stslex.core.network.api.kinopoisk.model.network.TrailerItemNetwork
+import com.stslex.core.network.api.kinopoisk.model.network.TrailerNetwork
+import com.stslex.core.network.api.kinopoisk.model.response.FilmItemResponse
+import com.stslex.core.network.api.kinopoisk.model.response.FilmListResponse
+import com.stslex.core.network.api.kinopoisk.model.response.MovieResponse
+import com.stslex.core.network.api.kinopoisk.model.response.TrailerItemResponse
+import com.stslex.core.network.api.kinopoisk.model.response.TrailerResponse
+
+fun FilmListResponse.toNetwork(): FilmListNetwork = FilmListNetwork(
+    total = total ?: 0,
+    totalPages = totalPages ?: 0,
+    items = items?.map { it.toNetwork() }.orEmpty()
+)
+
+fun FilmItemResponse.toNetwork(): FilmItemNetwork = FilmItemNetwork(
+    kinopoiskId = kinopoiskId,
+    imdbId = imdbId.orEmpty(),
+    nameRu = nameRu.orEmpty(),
+    nameEn = nameEn.orEmpty(),
+    nameOriginal = nameOriginal.orEmpty(),
+    countries = countries?.map { it.country }.orEmpty(),
+    genres = genres?.map { it.genre }.orEmpty(),
+    ratingKinopoisk = ratingKinopoisk,
+    ratingImdb = ratingImdb,
+    year = year,
+    posterUrl = posterUrl.orEmpty(),
+    posterUrlPreview = posterUrlPreview.orEmpty(),
+    type = FilmTypeNetwork.valueOf(type.orEmpty())
+)
+
+fun TrailerResponse.toNetwork(): TrailerNetwork = TrailerNetwork(
+    total = total ?: 0,
+    items = items?.map { it.toNetwork() }.orEmpty()
+)
+
+fun TrailerItemResponse.toNetwork(): TrailerItemNetwork = TrailerItemNetwork(
+    url = url.orEmpty(),
+    name = name.orEmpty(),
+    site = site.orEmpty(),
+)
+
+fun MovieResponse.toNetwork(): MovieNetwork = MovieNetwork(
+    kinopoiskId = kinopoiskId,
+    kinopoiskHDId = kinopoiskHDId.orEmpty(),
+    imdbId = imdbId.orEmpty(),
+    nameRu = nameRu.orEmpty(),
+    nameEn = nameEn.orEmpty(),
+    nameOriginal = nameOriginal.orEmpty(),
+    posterUrl = posterUrl.orEmpty(),
+    posterUrlPreview = posterUrlPreview.orEmpty(),
+    coverUrl = coverUrl.orEmpty(),
+    logoUrl = logoUrl.orEmpty(),
+    reviewsCount = reviewsCount,
+    ratingGoodReview = ratingGoodReview,
+    ratingGoodReviewVoteCount = ratingGoodReviewVoteCount,
+    ratingKinopoisk = ratingKinopoisk,
+    ratingKinopoiskVoteCount = ratingKinopoiskVoteCount,
+    ratingImdb = ratingImdb,
+    ratingImdbVoteCount = ratingImdbVoteCount,
+    ratingFilmCritics = ratingFilmCritics,
+    ratingFilmCriticsVoteCount = ratingFilmCriticsVoteCount,
+    ratingAwait = ratingAwait,
+    ratingAwaitCount = ratingAwaitCount,
+    ratingRfCritics = ratingRfCritics,
+    ratingRfCriticsVoteCount = ratingRfCriticsVoteCount,
+    webUrl = webUrl.orEmpty(),
+    year = year,
+    filmLength = filmLength,
+    slogan = slogan.orEmpty(),
+    description = description,
+    shortDescription = shortDescription.orEmpty(),
+    editorAnnotation = editorAnnotation.orEmpty(),
+    isTicketsAvailable = isTicketsAvailable ?: false,
+    productionStatus = FilmProductionStatusNetwork.fromValue(productionStatus.orEmpty()),
+    type = type,
+    ratingMpaa = ratingMpaa,
+    ratingAgeLimits = ratingAgeLimits,
+    hasImax = hasImax ?: false,
+    has3D = has3D ?: false,
+    lastSync = lastSync,
+    countries = countries?.map { it.country }.orEmpty(),
+    genres = genres?.map { it.genre }.orEmpty(),
+    startYear = startYear,
+    endYear = endYear,
+    isSerial = serial ?: false,
+    isShortFilm = shortFilm ?: false,
+    isCompleted = completed ?: false
+)

core/network/src/commonMain/kotlin/com/stslex/core/network/api/kinopoisk/model/network/FilmItemNetwork.kt

@@ -0,0 +1,17 @@
+package com.stslex.core.network.api.kinopoisk.model.network
+
+data class FilmItemNetwork(
+    val kinopoiskId: Int,
+    val imdbId: String,
+    val nameRu: String,
+    val nameEn: String,
+    val nameOriginal: String,
+    val countries: List<String>,
+    val genres: List<String>,
+    val ratingKinopoisk: Double?,
+    val ratingImdb: Double?,
+    val year: Int?,
+    val type: FilmTypeNetwork,
+    val posterUrl: String,
+    val posterUrlPreview: String
+)

core/network/src/commonMain/kotlin/com/stslex/core/network/api/kinopoisk/model/network/FilmListNetwork.kt

@@ -0,0 +1,7 @@
+package com.stslex.core.network.api.kinopoisk.model.network
+
+data class FilmListNetwork(
+    val total: Int,
+    val totalPages: Int,
+    val items: List<FilmItemNetwork>
+)

core/network/src/commonMain/kotlin/com/stslex/core/network/api/kinopoisk/model/network/FilmProductionStatusNetwork.kt

@@ -0,0 +1,17 @@
+package com.stslex.core.network.api.kinopoisk.model.network
+
+enum class FilmProductionStatusNetwork(val value: String) {
+    FILMING("FILMING"),
+    PRE_PRODUCTION("PRE_PRODUCTION"),
+    COMPLETED("COMPLETED"),
+    ANNOUNCED("ANNOUNCED"),
+    UNKNOWN("UNKNOWN"),
+    POST_PRODUCTION("POST_PRODUCTION");
+
+    companion object {
+        fun fromValue(value: String) = FilmProductionStatusNetwork
+            .entries
+            .firstOrNull { it.value == value }
+            ?: UNKNOWN
+    }
+}