content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package ru.pyroman.medanalytica.data.analysisgraph.cache
import ru.pyroman.medanalytica.data.analysisgraph.cache.dto.AnalysisGraphDataCacheDto
import ru.pyroman.medanalytica.data.analysisgraph.cache.dto.AnalysisGraphListCacheDto
import ru.pyroman.medanalytica.data.analysisgraph.cache.dto.AnalysisGraphPointCacheDto
import ru.pyroman.medanalytica.domain.analysisgraph.model.AnalysisGraphData
import ru.pyroman.medanalytica.domain.analysisgraph.model.AnalysisGraphList
import ru.pyroman.medanalytica.domain.analysisgraph.model.AnalysisGraphPoint
import javax.inject.Inject
internal class AnalysisGraphCacheMapper @Inject constructor() {
fun mapFromDto(dto: AnalysisGraphListCacheDto): AnalysisGraphList {
return dto.map { graphDataDto ->
mapAnalysisGraphData(graphDataDto)
}
}
fun mapToDto(model: AnalysisGraphList): AnalysisGraphListCacheDto {
return model.map(::mapAnalysisGraphData)
}
private fun mapAnalysisGraphData(dto: AnalysisGraphDataCacheDto): AnalysisGraphData {
val analysisType = dto.type
val units = dto.units
val points = dto.values.map(::mapAnalysisGraphPoint)
return AnalysisGraphData(
analysisType = analysisType,
units = units,
points = points,
)
}
private fun mapAnalysisGraphData(model: AnalysisGraphData): AnalysisGraphDataCacheDto {
val points = model.points.map(::mapAnalysisGraphPoint)
return AnalysisGraphDataCacheDto(
type = model.analysisType,
units = model.units,
values = points,
)
}
private fun mapAnalysisGraphPoint(dto: AnalysisGraphPointCacheDto): AnalysisGraphPoint {
val creationDateTime = dto.creationDateTime
val value = dto.value
return AnalysisGraphPoint(
creationDateTime = creationDateTime,
value = value,
)
}
private fun mapAnalysisGraphPoint(model: AnalysisGraphPoint): AnalysisGraphPointCacheDto {
return AnalysisGraphPointCacheDto(
value = model.value,
creationDateTime = model.creationDateTime,
)
}
} | MedAnalytica/data/analysis-graph-data/src/main/java/ru/pyroman/medanalytica/data/analysisgraph/cache/AnalysisGraphCacheMapper.kt | 235188719 |
package ru.pyroman.medanalytica.data.analysisgraph.cache
import ru.pyroman.medanalytica.data.analysisgraph.cache.database.AnalysisGraphDao
import ru.pyroman.medanalytica.data.analysisgraph.cache.dto.AnalysisGraphListCacheDto
import javax.inject.Inject
internal class AnalysisGraphCacheDataSource @Inject constructor(
private val dao: AnalysisGraphDao,
) {
suspend fun getGraphList(): AnalysisGraphListCacheDto {
return dao.getGraphList()
}
suspend fun searchGraphs(searchText: String): AnalysisGraphListCacheDto {
return dao.searchGraphs(searchText)
}
suspend fun setGraphList(graphList: AnalysisGraphListCacheDto) {
dao.deleteGraphList()
dao.insertGraphList(graphList)
}
suspend fun clearGraphList() {
dao.deleteGraphList()
}
} | MedAnalytica/data/analysis-graph-data/src/main/java/ru/pyroman/medanalytica/data/analysisgraph/cache/AnalysisGraphCacheDataSource.kt | 2969495247 |
package ru.pyroman.medanalytica.data.analysisgraph.network.dto
import com.google.gson.annotations.SerializedName
internal data class AnalysisGraphPointNetworkDto(
@SerializedName("value") val value: Float?,
@SerializedName("creationDate") val creationDateTime: String?,
) | MedAnalytica/data/analysis-graph-data/src/main/java/ru/pyroman/medanalytica/data/analysisgraph/network/dto/AnalysisGraphPointNetworkDto.kt | 718211617 |
package ru.pyroman.medanalytica.data.analysisgraph.network.dto
import com.google.gson.annotations.SerializedName
internal data class AnalysisGraphDataNetworkDto(
@SerializedName("type") val type: String?,
@SerializedName("units") val units: String?,
@SerializedName("valuesWithCreationDates") val values: List<AnalysisGraphPointNetworkDto?>?,
) | MedAnalytica/data/analysis-graph-data/src/main/java/ru/pyroman/medanalytica/data/analysisgraph/network/dto/AnalysisGraphDataNetworkDto.kt | 1150240303 |
package ru.pyroman.medanalytica.data.analysisgraph.network.dto
import com.google.gson.annotations.SerializedName
internal data class AnalysisGraphListNetworkDto(
@SerializedName("bloodTestsByTypeDtos")
val graphs: List<AnalysisGraphDataNetworkDto?>?
) | MedAnalytica/data/analysis-graph-data/src/main/java/ru/pyroman/medanalytica/data/analysisgraph/network/dto/AnalysisGraphListNetworkDto.kt | 1397086871 |
package ru.pyroman.medanalytica.data.analysisgraph.network
import ru.pyroman.medanalytica.data.analysisgraph.network.dto.AnalysisGraphDataNetworkDto
import ru.pyroman.medanalytica.data.analysisgraph.network.dto.AnalysisGraphListNetworkDto
import ru.pyroman.medanalytica.data.analysisgraph.network.dto.AnalysisGraphPointNetworkDto
import ru.pyroman.medanalytica.domain.analysisgraph.model.AnalysisGraphData
import ru.pyroman.medanalytica.domain.analysisgraph.model.AnalysisGraphList
import ru.pyroman.medanalytica.domain.analysisgraph.model.AnalysisGraphPoint
import javax.inject.Inject
internal class AnalysisGraphNetworkMapper @Inject constructor() {
fun map(dto: AnalysisGraphListNetworkDto): AnalysisGraphList {
return requireNotNull(dto.graphs).mapNotNull { graphDataDto ->
graphDataDto?.let { mapAnalysisGraphData(it) }
}
}
private fun mapAnalysisGraphData(dto: AnalysisGraphDataNetworkDto): AnalysisGraphData {
val analysisType = dto.type.orEmpty()
val units = dto.units.orEmpty()
val points = dto.values.orEmpty().mapNotNull { pointDto ->
pointDto?.let { mapAnalysisGraphPoint(it) }
}
return AnalysisGraphData(
analysisType = analysisType,
units = units,
points = points,
)
}
private fun mapAnalysisGraphPoint(dto: AnalysisGraphPointNetworkDto): AnalysisGraphPoint {
val creationDateTime = dto.creationDateTime.orEmpty()
val value = dto.value ?: 0f
return AnalysisGraphPoint(
creationDateTime = creationDateTime,
value = value,
)
}
} | MedAnalytica/data/analysis-graph-data/src/main/java/ru/pyroman/medanalytica/data/analysisgraph/network/AnalysisGraphNetworkMapper.kt | 1196865449 |
package ru.pyroman.medanalytica.data.analysisgraph.network
import ru.pyroman.medanalytica.data.analysisgraph.network.api.AnalysisGraphNetworkApi
import ru.pyroman.medanalytica.data.analysisgraph.network.dto.AnalysisGraphListNetworkDto
import ru.pyroman.medanalytica.domain.token.model.Token
import ru.pyroman.medanalytica.domain.uid.model.Uid
import javax.inject.Inject
internal class AnalysisGraphNetworkDataSource @Inject constructor(
private val api: AnalysisGraphNetworkApi,
) {
suspend fun getGraphList(
uid: Uid,
token: Token,
): AnalysisGraphListNetworkDto {
return api.getGraphList(uid, token)
}
} | MedAnalytica/data/analysis-graph-data/src/main/java/ru/pyroman/medanalytica/data/analysisgraph/network/AnalysisGraphNetworkDataSource.kt | 2285595517 |
package ru.pyroman.medanalytica.data.analysisgraph.network.api
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.http.GET
import retrofit2.http.Header
import retrofit2.http.Path
import ru.pyroman.medanalytica.data.analysisgraph.network.dto.AnalysisGraphListNetworkDto
import ru.pyroman.medanalytica.domain.token.model.Token
import ru.pyroman.medanalytica.domain.uid.model.Uid
internal interface AnalysisGraphNetworkApi {
@GET("bloodTest/bloodTests/all/{uid}")
suspend fun getGraphList(
@Path("uid") uid: Uid,
@Header("token") token: Token,
): AnalysisGraphListNetworkDto
companion object {
private const val BASE_URL = "http://51.250.107.247:8080"
fun build(): AnalysisGraphNetworkApi = Retrofit.Builder()
.baseUrl(BASE_URL)
.addConverterFactory(GsonConverterFactory.create())
.build()
.create(AnalysisGraphNetworkApi::class.java)
}
} | MedAnalytica/data/analysis-graph-data/src/main/java/ru/pyroman/medanalytica/data/analysisgraph/network/api/AnalysisGraphNetworkApi.kt | 3699281603 |
package ru.pyroman.medanalytica.data.uid.repository
import ru.pyroman.medanalytica.data.uid.cache.UidCacheDataSource
import ru.pyroman.medanalytica.domain.uid.model.Uid
import ru.pyroman.medanalytica.domain.uid.repository.UidRepository
import javax.inject.Inject
class UidRepositoryImpl @Inject internal constructor(
private val cacheDataSource: UidCacheDataSource,
) : UidRepository {
override suspend fun setUid(uid: Uid) {
return cacheDataSource.setUid(uid)
}
override suspend fun getUid(): Uid? {
return cacheDataSource.getUid()
}
override suspend fun clearUid() {
return cacheDataSource.clearUid()
}
} | MedAnalytica/data/uid-data/src/main/java/ru/pyroman/medanalytica/data/uid/repository/UidRepositoryImpl.kt | 2637528545 |
package ru.pyroman.medanalytica.data.uid.di
import android.content.Context
import dagger.Binds
import dagger.Module
import dagger.Provides
import ru.pyroman.medanalytica.data.uid.cache.UidCacheDataSource
import ru.pyroman.medanalytica.data.uid.repository.UidRepositoryImpl
import ru.pyroman.medanalytica.domain.uid.repository.UidRepository
@Module
interface UidDataModule {
@Binds
fun bindUidRepository(impl: UidRepositoryImpl): UidRepository
companion object {
@Provides
internal fun provideUidCacheDataStore(
applicationContext: Context,
): UidCacheDataSource {
return UidCacheDataSource(
applicationContext = applicationContext,
)
}
@Provides
internal fun provideUidRepositoryImpl(
cacheDataSource: UidCacheDataSource,
): UidRepositoryImpl {
return UidRepositoryImpl(
cacheDataSource = cacheDataSource,
)
}
}
} | MedAnalytica/data/uid-data/src/main/java/ru/pyroman/medanalytica/data/uid/di/UidDataModule.kt | 842198828 |
package ru.pyroman.medanalytica.data.uid.cache
import android.content.Context
import androidx.security.crypto.EncryptedSharedPreferences
import androidx.security.crypto.MasterKeys
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import ru.pyroman.medanalytica.domain.uid.model.Uid
import javax.inject.Inject
internal class UidCacheDataSource @Inject constructor(
applicationContext: Context,
) {
private val masterKey = MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC)
private val sharedPreferences = EncryptedSharedPreferences.create(
FILE_NAME,
masterKey,
applicationContext,
EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM,
)
suspend fun setUid(uid: Uid) {
withContext(Dispatchers.Main) {
sharedPreferences.edit()
.putString(UID_KEY, uid.toString())
.apply()
}
}
suspend fun getUid(): Uid? {
return withContext(Dispatchers.Main) {
sharedPreferences.getString(UID_KEY, null)?.toLongOrNull()
}
}
suspend fun clearUid() {
return withContext(Dispatchers.Main) {
sharedPreferences.edit()
.remove(UID_KEY)
.apply()
}
}
companion object {
private const val FILE_NAME = "preferences"
private const val UID_KEY = "uid"
}
} | MedAnalytica/data/uid-data/src/main/java/ru/pyroman/medanalytica/data/uid/cache/UidCacheDataSource.kt | 4134516247 |
package ru.pyroman.medanalytica.data.token.repository
import ru.pyroman.medanalytica.data.token.cache.TokenCacheDataSource
import ru.pyroman.medanalytica.domain.token.model.Token
import ru.pyroman.medanalytica.domain.token.repository.TokenRepository
import javax.inject.Inject
class TokenRepositoryImpl @Inject internal constructor(
private val cacheDataSource: TokenCacheDataSource,
) : TokenRepository {
override suspend fun setToken(token: Token) {
return cacheDataSource.setToken(token)
}
override suspend fun getToken(): Token? {
return cacheDataSource.getToken()
}
override suspend fun clearToken() {
return cacheDataSource.clearToken()
}
} | MedAnalytica/data/token-data/src/main/java/ru/pyroman/medanalytica/data/token/repository/TokenRepositoryImpl.kt | 66661839 |
package ru.pyroman.medanalytica.data.token.di
import android.content.Context
import dagger.Binds
import dagger.Module
import dagger.Provides
import ru.pyroman.medanalytica.data.token.cache.TokenCacheDataSource
import ru.pyroman.medanalytica.data.token.repository.TokenRepositoryImpl
import ru.pyroman.medanalytica.domain.token.repository.TokenRepository
@Module
interface TokenDataModule {
@Binds
fun bindTokenRepository(impl: TokenRepositoryImpl): TokenRepository
companion object {
@Provides
internal fun provideTokenCacheDataStore(
applicationContext: Context,
): TokenCacheDataSource {
return TokenCacheDataSource(
applicationContext = applicationContext,
)
}
@Provides
internal fun provideTokenRepositoryImpl(
cacheDataSource: TokenCacheDataSource,
): TokenRepositoryImpl {
return TokenRepositoryImpl(
cacheDataSource = cacheDataSource,
)
}
}
} | MedAnalytica/data/token-data/src/main/java/ru/pyroman/medanalytica/data/token/di/TokenDataModule.kt | 1155795083 |
package ru.pyroman.medanalytica.data.token.cache
import android.content.Context
import androidx.security.crypto.EncryptedSharedPreferences
import androidx.security.crypto.MasterKeys
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import ru.pyroman.medanalytica.domain.token.model.Token
import javax.inject.Inject
internal class TokenCacheDataSource @Inject constructor(
applicationContext: Context,
) {
private val masterKey = MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC)
private val sharedPreferences = EncryptedSharedPreferences.create(
FILE_NAME,
masterKey,
applicationContext,
EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM,
)
suspend fun setToken(token: Token) {
withContext(Dispatchers.Main) {
sharedPreferences.edit()
.putString(TOKEN_KEY, token)
.apply()
}
}
suspend fun getToken(): Token? {
return withContext(Dispatchers.Main) {
sharedPreferences.getString(TOKEN_KEY, null)
}
}
suspend fun clearToken() {
return withContext(Dispatchers.Main) {
sharedPreferences.edit()
.remove(TOKEN_KEY)
.apply()
}
}
companion object {
private const val FILE_NAME = "preferences"
private const val TOKEN_KEY = "token"
}
} | MedAnalytica/data/token-data/src/main/java/ru/pyroman/medanalytica/data/token/cache/TokenCacheDataSource.kt | 3670299498 |
package ru.pyroman.medanalytica.data.profile.repository
import ru.pyroman.medanalytica.data.profile.network.ProfileNetworkDataSource
import ru.pyroman.medanalytica.data.profile.network.ProfileNetworkMapper
import ru.pyroman.medanalytica.domain.profile.domain.ProfileData
import ru.pyroman.medanalytica.domain.profile.repository.ProfileRepository
import ru.pyroman.medanalytica.domain.token.repository.TokenRepository
import ru.pyroman.medanalytica.domain.uid.repository.UidRepository
import javax.inject.Inject
class ProfileRepositoryImpl @Inject internal constructor(
private val uidRepository: UidRepository,
private val tokenRepository: TokenRepository,
private val networkDataSource: ProfileNetworkDataSource,
private val networkMapper: ProfileNetworkMapper,
) : ProfileRepository {
override suspend fun getProfileData(): ProfileData {
return getProfileDataFromNetwork()
}
override suspend fun patchProfileData(data: ProfileData) {
return patchProfileDataInNetwork(data)
}
private suspend fun getProfileDataFromNetwork(): ProfileData {
val uid = requireNotNull(uidRepository.getUid())
val token = requireNotNull(tokenRepository.getToken())
val dto = networkDataSource.getProfileData(
uid = uid,
token = token,
)
return networkMapper.map(dto)
}
private suspend fun patchProfileDataInNetwork(data: ProfileData) {
val uid = requireNotNull(uidRepository.getUid())
val token = requireNotNull(tokenRepository.getToken())
val dto = networkMapper.map(data)
return networkDataSource.patchProfileData(
uid = uid,
token = token,
data = dto,
)
}
} | MedAnalytica/data/profile-data/src/main/java/ru/pyroman/medanalytica/data/profile/repository/ProfileRepositoryImpl.kt | 2623989311 |
package ru.pyroman.medanalytica.data.profile.di
import dagger.Binds
import dagger.Module
import dagger.Provides
import ru.pyroman.medanalytica.data.profile.network.ProfileNetworkDataSource
import ru.pyroman.medanalytica.data.profile.network.ProfileNetworkMapper
import ru.pyroman.medanalytica.data.profile.network.api.ProfileNetworkApi
import ru.pyroman.medanalytica.data.profile.repository.ProfileRepositoryImpl
import ru.pyroman.medanalytica.domain.profile.repository.ProfileRepository
import ru.pyroman.medanalytica.domain.token.repository.TokenRepository
import ru.pyroman.medanalytica.domain.uid.repository.UidRepository
@Module
interface ProfileDataModule {
@Binds
fun bindProfileRepository(
impl: ProfileRepositoryImpl,
): ProfileRepository
companion object {
@Provides
internal fun provideProfileNetworkApi(): ProfileNetworkApi {
return ProfileNetworkApi.build()
}
@Provides
internal fun provideProfileNetworkMapper(): ProfileNetworkMapper {
return ProfileNetworkMapper()
}
@Provides
internal fun provideProfileNetworkDataSource(
api: ProfileNetworkApi
): ProfileNetworkDataSource {
return ProfileNetworkDataSource(
api = api,
)
}
@Provides
internal fun provideProfileRepositoryImpl(
uidRepository: UidRepository,
tokenRepository: TokenRepository,
networkDataSource: ProfileNetworkDataSource,
networkMapper: ProfileNetworkMapper,
): ProfileRepositoryImpl {
return ProfileRepositoryImpl(
uidRepository = uidRepository,
tokenRepository = tokenRepository,
networkDataSource = networkDataSource,
networkMapper = networkMapper,
)
}
}
} | MedAnalytica/data/profile-data/src/main/java/ru/pyroman/medanalytica/data/profile/di/ProfileDataModule.kt | 3182646867 |
package ru.pyroman.medanalytica.data.profile.network.dto
import com.google.gson.annotations.SerializedName
internal data class ProfileDataNetworkDto(
@SerializedName("name") val name: String?,
@SerializedName("surname") val surname: String?,
@SerializedName("dateOfBirth") val dateOfBirth: String?,
@SerializedName("weight") val weight: Int?,
@SerializedName("height") val height: Int?,
@SerializedName("bloodType") val bloodType: String?,
) | MedAnalytica/data/profile-data/src/main/java/ru/pyroman/medanalytica/data/profile/network/dto/ProfileDataNetworkDto.kt | 3982282264 |
package ru.pyroman.medanalytica.data.profile.network
import ru.pyroman.medanalytica.data.profile.network.dto.ProfileDataNetworkDto
import ru.pyroman.medanalytica.domain.profile.domain.BloodType
import ru.pyroman.medanalytica.domain.profile.domain.ProfileData
internal class ProfileNetworkMapper {
fun map(model: ProfileData): ProfileDataNetworkDto {
return ProfileDataNetworkDto(
name = model.name,
surname = model.surname,
dateOfBirth = model.dateOfBirth,
weight = model.weight,
height = model.height,
bloodType = model.bloodType?.let { mapBloodType(it) },
)
}
fun map(dto: ProfileDataNetworkDto): ProfileData {
return ProfileData(
name = dto.name.orEmpty(),
surname = dto.surname.orEmpty(),
dateOfBirth = dto.dateOfBirth.orEmpty(),
weight = dto.weight,
height = dto.height,
bloodType = dto.bloodType?.let { mapBloodType(it) }
)
}
private fun mapBloodType(model: BloodType): String {
return model.value
}
private fun mapBloodType(dto: String): BloodType? {
return BloodType.fromValue(dto)
}
} | MedAnalytica/data/profile-data/src/main/java/ru/pyroman/medanalytica/data/profile/network/ProfileNetworkMapper.kt | 3718685739 |
package ru.pyroman.medanalytica.data.profile.network
import ru.pyroman.medanalytica.data.profile.network.api.ProfileNetworkApi
import ru.pyroman.medanalytica.data.profile.network.dto.ProfileDataNetworkDto
import ru.pyroman.medanalytica.domain.token.model.Token
import ru.pyroman.medanalytica.domain.uid.model.Uid
internal class ProfileNetworkDataSource(
private val api: ProfileNetworkApi
) {
suspend fun getProfileData(
uid: Uid,
token: Token,
): ProfileDataNetworkDto {
return api.getProfileData(
uid = uid,
token = token,
)
}
suspend fun patchProfileData(
uid: Uid,
token: Token,
data: ProfileDataNetworkDto
) {
return api.patchProfileData(
uid = uid,
token = token,
data = data,
)
}
} | MedAnalytica/data/profile-data/src/main/java/ru/pyroman/medanalytica/data/profile/network/ProfileNetworkDataSource.kt | 2658226676 |
package ru.pyroman.medanalytica.data.profile.network.api
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.http.Body
import retrofit2.http.GET
import retrofit2.http.Header
import retrofit2.http.PATCH
import retrofit2.http.Path
import ru.pyroman.medanalytica.data.profile.network.dto.ProfileDataNetworkDto
import ru.pyroman.medanalytica.domain.token.model.Token
import ru.pyroman.medanalytica.domain.uid.model.Uid
internal interface ProfileNetworkApi {
@GET("/users/{uid}")
suspend fun getProfileData(
@Path("uid") uid: Uid,
@Header("token") token: Token,
): ProfileDataNetworkDto
@PATCH("/users/{uid}")
suspend fun patchProfileData(
@Path("uid") uid: Uid,
@Header("token") token: Token,
@Body data: ProfileDataNetworkDto
)
companion object {
private const val BASE_URL = "http://51.250.107.247:8080"
fun build(): ProfileNetworkApi = Retrofit.Builder()
.baseUrl(BASE_URL)
.addConverterFactory(GsonConverterFactory.create())
.build()
.create(ProfileNetworkApi::class.java)
}
} | MedAnalytica/data/profile-data/src/main/java/ru/pyroman/medanalytica/data/profile/network/api/ProfileNetworkApi.kt | 3477102993 |
package ru.pyroman.medanalytica.data.postanalysis.repository
import retrofit2.HttpException
import ru.pyroman.medanalytica.common.utils.extractMessage
import ru.pyroman.medanalytica.data.postanalysis.network.PostAnalysisNetworkDataSource
import ru.pyroman.medanalytica.data.postanalysis.network.PostAnalysisNetworkMapper
import ru.pyroman.medanalytica.domain.postanalysis.model.PostAnalysisData
import ru.pyroman.medanalytica.domain.postanalysis.model.PostAnalysisResult
import ru.pyroman.medanalytica.domain.postanalysis.repository.PostAnalysisRepository
import ru.pyroman.medanalytica.domain.token.repository.TokenRepository
import ru.pyroman.medanalytica.domain.uid.repository.UidRepository
import javax.inject.Inject
class PostAnalysisRepositoryImpl @Inject internal constructor(
private val uidRepository: UidRepository,
private val tokenRepository: TokenRepository,
private val networkDataSource: PostAnalysisNetworkDataSource,
private val networkMapper: PostAnalysisNetworkMapper,
) : PostAnalysisRepository {
override suspend fun postAnalysis(data: PostAnalysisData): PostAnalysisResult {
return try {
val uid = requireNotNull(uidRepository.getUid())
val token = requireNotNull(tokenRepository.getToken())
val dto = networkMapper.map(data)
networkDataSource.postAnalysis(
uid = uid,
token = token,
postAnalysis = dto,
)
PostAnalysisResult.Success
} catch (error: Throwable) {
val defaultMessage = "Ошибка загрузки анализа, повторите попытку"
val message = (error as? HttpException)?.let {
error.extractMessage(defaultMessage)
} ?: defaultMessage
PostAnalysisResult.Error(
message = message
)
}
}
} | MedAnalytica/data/post-analysis-data/src/main/java/ru/pyroman/medanalytica/data/postanalysis/repository/PostAnalysisRepositoryImpl.kt | 428617478 |
package ru.pyroman.medanalytica.data.postanalysis.di
import dagger.Binds
import dagger.Module
import dagger.Provides
import ru.pyroman.medanalytica.data.postanalysis.network.PostAnalysisNetworkDataSource
import ru.pyroman.medanalytica.data.postanalysis.network.PostAnalysisNetworkMapper
import ru.pyroman.medanalytica.data.postanalysis.network.api.PostAnalysisNetworkApi
import ru.pyroman.medanalytica.data.postanalysis.repository.PostAnalysisRepositoryImpl
import ru.pyroman.medanalytica.domain.postanalysis.repository.PostAnalysisRepository
import ru.pyroman.medanalytica.domain.token.repository.TokenRepository
import ru.pyroman.medanalytica.domain.uid.repository.UidRepository
@Module
interface PostAnalysisDataModule {
@Binds
fun bindPostAnalysisRepository(
impl: PostAnalysisRepositoryImpl,
): PostAnalysisRepository
companion object {
@Provides
internal fun providePostAnalysisNetworkApi(): PostAnalysisNetworkApi {
return PostAnalysisNetworkApi.build()
}
@Provides
internal fun providePostAnalysisNetworkMapper(): PostAnalysisNetworkMapper {
return PostAnalysisNetworkMapper()
}
@Provides
internal fun providePostAnalysisNetworkDataSource(
api: PostAnalysisNetworkApi
): PostAnalysisNetworkDataSource {
return PostAnalysisNetworkDataSource(
api = api,
)
}
@Provides
internal fun providePostAnalysisRepositoryImpl(
uidRepository: UidRepository,
tokenRepository: TokenRepository,
networkDataSource: PostAnalysisNetworkDataSource,
networkMapper: PostAnalysisNetworkMapper,
): PostAnalysisRepositoryImpl {
return PostAnalysisRepositoryImpl(
uidRepository = uidRepository,
tokenRepository = tokenRepository,
networkDataSource = networkDataSource,
networkMapper = networkMapper,
)
}
}
} | MedAnalytica/data/post-analysis-data/src/main/java/ru/pyroman/medanalytica/data/postanalysis/di/PostAnalysisDataModule.kt | 3934620157 |
package ru.pyroman.medanalytica.data.postanalysis.network.dto
import com.google.gson.annotations.SerializedName
class PostAnalysisNetworkDto (
@SerializedName("file") val file: String,
) | MedAnalytica/data/post-analysis-data/src/main/java/ru/pyroman/medanalytica/data/postanalysis/network/dto/PostAnalysisNetworkDto.kt | 1420471962 |
package ru.pyroman.medanalytica.data.postanalysis.network
import ru.pyroman.medanalytica.data.postanalysis.network.dto.PostAnalysisNetworkDto
import ru.pyroman.medanalytica.domain.postanalysis.model.PostAnalysisData
class PostAnalysisNetworkMapper {
fun map(data: PostAnalysisData): PostAnalysisNetworkDto {
return PostAnalysisNetworkDto(
file = data.file,
)
}
} | MedAnalytica/data/post-analysis-data/src/main/java/ru/pyroman/medanalytica/data/postanalysis/network/PostAnalysisNetworkMapper.kt | 2540267616 |
package ru.pyroman.medanalytica.data.postanalysis.network
import ru.pyroman.medanalytica.data.postanalysis.network.api.PostAnalysisNetworkApi
import ru.pyroman.medanalytica.data.postanalysis.network.dto.PostAnalysisNetworkDto
import ru.pyroman.medanalytica.domain.token.model.Token
import ru.pyroman.medanalytica.domain.uid.model.Uid
import javax.inject.Inject
internal class PostAnalysisNetworkDataSource @Inject constructor(
private val api: PostAnalysisNetworkApi,
) {
suspend fun postAnalysis(
uid: Uid,
token: Token,
postAnalysis: PostAnalysisNetworkDto,
) {
api.getGraphList(
uid = uid,
token = token,
postAnalysis = postAnalysis,
)
}
} | MedAnalytica/data/post-analysis-data/src/main/java/ru/pyroman/medanalytica/data/postanalysis/network/PostAnalysisNetworkDataSource.kt | 635946899 |
package ru.pyroman.medanalytica.data.postanalysis.network.api
import okhttp3.OkHttpClient
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.http.Body
import retrofit2.http.Header
import retrofit2.http.POST
import retrofit2.http.Path
import ru.pyroman.medanalytica.data.postanalysis.network.dto.PostAnalysisNetworkDto
import ru.pyroman.medanalytica.domain.token.model.Token
import ru.pyroman.medanalytica.domain.uid.model.Uid
import java.util.concurrent.TimeUnit
internal interface PostAnalysisNetworkApi {
@POST("bloodTest/bloodTests/save/{uid}")
suspend fun getGraphList(
@Path("uid") uid: Uid,
@Header("token") token: Token,
@Body postAnalysis: PostAnalysisNetworkDto,
)
companion object {
private const val BASE_URL = "http://51.250.107.247:8080"
fun build(): PostAnalysisNetworkApi = Retrofit.Builder()
.baseUrl(BASE_URL)
.client(OkHttpClient.Builder()
.readTimeout(60, TimeUnit.SECONDS)
.connectTimeout(60, TimeUnit.SECONDS)
.build()
)
.addConverterFactory(GsonConverterFactory.create())
.build()
.create(PostAnalysisNetworkApi::class.java)
}
} | MedAnalytica/data/post-analysis-data/src/main/java/ru/pyroman/medanalytica/data/postanalysis/network/api/PostAnalysisNetworkApi.kt | 2530429548 |
package ru.pyroman.medanalytica.data.register.repository
import retrofit2.HttpException
import ru.pyroman.medanalytica.common.utils.extractMessage
import ru.pyroman.medanalytica.data.register.network.RegisterNetworkDataSource
import ru.pyroman.medanalytica.data.register.network.RegisterNetworkMapper
import ru.pyroman.medanalytica.domain.register.model.RegisterData
import ru.pyroman.medanalytica.domain.register.model.RegisterResult
import ru.pyroman.medanalytica.domain.register.repository.RegisterRepository
import ru.pyroman.medanalytica.domain.token.repository.TokenRepository
import ru.pyroman.medanalytica.domain.uid.repository.UidRepository
import javax.inject.Inject
class RegisterRepositoryImpl @Inject internal constructor(
private val networkDataSource: RegisterNetworkDataSource,
private val networkMapper: RegisterNetworkMapper,
private val uidRepository: UidRepository,
private val tokenRepository: TokenRepository,
) : RegisterRepository {
override suspend fun register(data: RegisterData): RegisterResult {
return try {
val registerDataDto = networkMapper.map(data)
val registerResultDto = networkDataSource.register(registerDataDto)
val uid = requireNotNull(registerResultDto.uid)
val token = requireNotNull(registerResultDto.token)
uidRepository.setUid(uid)
tokenRepository.setToken(token)
RegisterResult.Success
} catch (error: Throwable) {
val defaultMessage = "Ошибка регистрации!"
val message = (error as? HttpException)?.let {
error.extractMessage(defaultMessage)
} ?: defaultMessage
RegisterResult.Failure(message)
}
}
} | MedAnalytica/data/register-data/src/main/java/ru/pyroman/medanalytica/data/register/repository/RegisterRepositoryImpl.kt | 1116008313 |
package ru.pyroman.medanalytica.data.register.di
import dagger.Binds
import dagger.Module
import dagger.Provides
import ru.pyroman.medanalytica.data.register.network.RegisterNetworkDataSource
import ru.pyroman.medanalytica.data.register.network.RegisterNetworkMapper
import ru.pyroman.medanalytica.data.register.network.api.RegisterNetworkApi
import ru.pyroman.medanalytica.data.register.repository.RegisterRepositoryImpl
import ru.pyroman.medanalytica.domain.register.repository.RegisterRepository
import ru.pyroman.medanalytica.domain.token.repository.TokenRepository
import ru.pyroman.medanalytica.domain.uid.repository.UidRepository
@Module
interface RegisterDataModule {
@Binds
fun bindRegisterRepository(
impl: RegisterRepositoryImpl,
): RegisterRepository
companion object {
@Provides
internal fun provideRegisterNetworkApi(): RegisterNetworkApi {
return RegisterNetworkApi.build()
}
@Provides
internal fun provideRegisterNetworkMapper(): RegisterNetworkMapper {
return RegisterNetworkMapper()
}
@Provides
internal fun provideRegisterNetworkDataSource(
api: RegisterNetworkApi
): RegisterNetworkDataSource {
return RegisterNetworkDataSource(
api = api,
)
}
@Provides
internal fun provideRegisterRepositoryImpl(
uidRepository: UidRepository,
tokenRepository: TokenRepository,
networkDataSource: RegisterNetworkDataSource,
networkMapper: RegisterNetworkMapper,
): RegisterRepositoryImpl {
return RegisterRepositoryImpl(
uidRepository = uidRepository,
tokenRepository = tokenRepository,
networkDataSource = networkDataSource,
networkMapper = networkMapper,
)
}
}
} | MedAnalytica/data/register-data/src/main/java/ru/pyroman/medanalytica/data/register/di/RegisterDataModule.kt | 2021805403 |
package ru.pyroman.medanalytica.data.register.network.dto
import com.google.gson.annotations.SerializedName
import ru.pyroman.medanalytica.domain.token.model.Token
import ru.pyroman.medanalytica.domain.uid.model.Uid
class RegisterResultNetworkDto(
@SerializedName("userId") val uid: Uid?,
@SerializedName("token") val token: Token?,
)
| MedAnalytica/data/register-data/src/main/java/ru/pyroman/medanalytica/data/register/network/dto/RegisterResultNetworkDto.kt | 2364591301 |
package ru.pyroman.medanalytica.data.register.network.dto
import com.google.gson.annotations.SerializedName
class RegisterDataNetworkDto(
@SerializedName("login") val login: String,
@SerializedName("password") val password: String,
@SerializedName("name") val name: String?,
@SerializedName("surname") val surname: String?,
@SerializedName("dateOfBirth") val dateOfBirth: String?,
@SerializedName("weight") val weight: Int?,
@SerializedName("height") val height: Int?,
) | MedAnalytica/data/register-data/src/main/java/ru/pyroman/medanalytica/data/register/network/dto/RegisterDataNetworkDto.kt | 1680798833 |
package ru.pyroman.medanalytica.data.register.network
import ru.pyroman.medanalytica.data.register.network.api.RegisterNetworkApi
import ru.pyroman.medanalytica.data.register.network.dto.RegisterDataNetworkDto
import ru.pyroman.medanalytica.data.register.network.dto.RegisterResultNetworkDto
import javax.inject.Inject
internal class RegisterNetworkDataSource @Inject constructor(
private val api: RegisterNetworkApi,
){
suspend fun register(dto: RegisterDataNetworkDto): RegisterResultNetworkDto {
return api.register(dto)
}
} | MedAnalytica/data/register-data/src/main/java/ru/pyroman/medanalytica/data/register/network/RegisterNetworkDataSource.kt | 2565115588 |
package ru.pyroman.medanalytica.data.register.network.api
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.http.Body
import retrofit2.http.POST
import ru.pyroman.medanalytica.data.register.network.dto.RegisterDataNetworkDto
import ru.pyroman.medanalytica.data.register.network.dto.RegisterResultNetworkDto
internal interface RegisterNetworkApi {
@POST("/registration/register")
suspend fun register(
@Body loginDataNetworkDto: RegisterDataNetworkDto,
): RegisterResultNetworkDto
companion object {
private const val BASE_URL = "http://51.250.107.247:8080"
fun build(): RegisterNetworkApi = Retrofit.Builder()
.baseUrl(BASE_URL)
.addConverterFactory(GsonConverterFactory.create())
.build()
.create(RegisterNetworkApi::class.java)
}
} | MedAnalytica/data/register-data/src/main/java/ru/pyroman/medanalytica/data/register/network/api/RegisterNetworkApi.kt | 2305134225 |
package ru.pyroman.medanalytica.data.register.network
import ru.pyroman.medanalytica.data.register.network.dto.RegisterDataNetworkDto
import ru.pyroman.medanalytica.domain.register.model.RegisterData
class RegisterNetworkMapper {
fun map(model: RegisterData): RegisterDataNetworkDto {
return RegisterDataNetworkDto(
login = model.login,
password = model.password,
name = model.name,
surname = model.surname,
dateOfBirth = model.dateOfBirth,
weight = model.weight,
height = model.height,
)
}
} | MedAnalytica/data/register-data/src/main/java/ru/pyroman/medanalytica/data/register/network/RegisterNetworkMapper.kt | 3429120522 |
package ru.pyroman.medanalytica.data.login.repository
import retrofit2.HttpException
import ru.pyroman.medanalytica.common.utils.extractMessage
import ru.pyroman.medanalytica.data.login.network.LoginNetworkDataSource
import ru.pyroman.medanalytica.data.login.network.LoginNetworkMapper
import ru.pyroman.medanalytica.domain.login.model.LoginData
import ru.pyroman.medanalytica.domain.login.model.LoginResult
import ru.pyroman.medanalytica.domain.login.repository.LoginRepository
import ru.pyroman.medanalytica.domain.token.repository.TokenRepository
import ru.pyroman.medanalytica.domain.uid.repository.UidRepository
import javax.inject.Inject
class LoginRepositoryImpl @Inject internal constructor(
private val networkDataSource: LoginNetworkDataSource,
private val networkMapper: LoginNetworkMapper,
private val uidRepository: UidRepository,
private val tokenRepository: TokenRepository,
) : LoginRepository {
override suspend fun login(data: LoginData): LoginResult {
return try {
val loginDataDto = networkMapper.map(data)
val loginResultDto = networkDataSource.login(loginDataDto)
val uid = requireNotNull(loginResultDto.uid)
val token = requireNotNull(loginResultDto.token)
uidRepository.setUid(uid)
tokenRepository.setToken(token)
LoginResult.Success
} catch (error: Throwable) {
val defaultMessage = "Ошибка авторизации!"
val message = (error as? HttpException)?.let {
error.extractMessage(defaultMessage)
} ?: defaultMessage
LoginResult.Failure(message)
}
}
} | MedAnalytica/data/login-data/src/main/java/ru/pyroman/medanalytica/data/login/repository/LoginRepositoryImpl.kt | 2094629214 |
package ru.pyroman.medanalytica.data.login.di
import dagger.Binds
import dagger.Module
import dagger.Provides
import ru.pyroman.medanalytica.data.login.network.LoginNetworkDataSource
import ru.pyroman.medanalytica.data.login.network.LoginNetworkMapper
import ru.pyroman.medanalytica.data.login.network.api.LoginNetworkApi
import ru.pyroman.medanalytica.data.login.repository.LoginRepositoryImpl
import ru.pyroman.medanalytica.domain.login.repository.LoginRepository
import ru.pyroman.medanalytica.domain.token.repository.TokenRepository
import ru.pyroman.medanalytica.domain.uid.repository.UidRepository
@Module
interface LoginDataModule {
@Binds
fun bindLoginRepository(
impl: LoginRepositoryImpl,
): LoginRepository
companion object {
@Provides
internal fun provideLoginNetworkApi(): LoginNetworkApi {
return LoginNetworkApi.build()
}
@Provides
internal fun provideLoginNetworkMapper(): LoginNetworkMapper {
return LoginNetworkMapper()
}
@Provides
internal fun provideLoginNetworkDataSource(
api: LoginNetworkApi
): LoginNetworkDataSource {
return LoginNetworkDataSource(
api = api,
)
}
@Provides
internal fun provideLoginRepositoryImpl(
uidRepository: UidRepository,
tokenRepository: TokenRepository,
networkDataSource: LoginNetworkDataSource,
networkMapper: LoginNetworkMapper,
): LoginRepositoryImpl {
return LoginRepositoryImpl(
uidRepository = uidRepository,
tokenRepository = tokenRepository,
networkDataSource = networkDataSource,
networkMapper = networkMapper,
)
}
}
} | MedAnalytica/data/login-data/src/main/java/ru/pyroman/medanalytica/data/login/di/LoginDataModule.kt | 1920113563 |
package ru.pyroman.medanalytica.data.login.network.dto
import com.google.gson.annotations.SerializedName
class LoginResultNetworkDto(
@SerializedName("userId") val uid: Long?,
@SerializedName("token") val token: String?,
) | MedAnalytica/data/login-data/src/main/java/ru/pyroman/medanalytica/data/login/network/dto/LoginResultNetworkDto.kt | 4077637585 |
package ru.pyroman.medanalytica.data.login.network.dto
import com.google.gson.annotations.SerializedName
class LoginDataNetworkDto(
@SerializedName("login") val login: String?,
@SerializedName("password") val password: String?,
) | MedAnalytica/data/login-data/src/main/java/ru/pyroman/medanalytica/data/login/network/dto/LoginDataNetworkDto.kt | 919178889 |
package ru.pyroman.medanalytica.data.login.network
import ru.pyroman.medanalytica.data.login.network.api.LoginNetworkApi
import ru.pyroman.medanalytica.data.login.network.dto.LoginDataNetworkDto
import ru.pyroman.medanalytica.data.login.network.dto.LoginResultNetworkDto
import javax.inject.Inject
internal class LoginNetworkDataSource @Inject constructor(
private val api: LoginNetworkApi,
){
suspend fun login(dto: LoginDataNetworkDto): LoginResultNetworkDto {
return api.login(dto)
}
} | MedAnalytica/data/login-data/src/main/java/ru/pyroman/medanalytica/data/login/network/LoginNetworkDataSource.kt | 259155631 |
package ru.pyroman.medanalytica.data.login.network.api
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.http.Body
import retrofit2.http.POST
import ru.pyroman.medanalytica.data.login.network.dto.LoginDataNetworkDto
import ru.pyroman.medanalytica.data.login.network.dto.LoginResultNetworkDto
internal interface LoginNetworkApi {
@POST("/registration/authorize")
suspend fun login(
@Body loginDataNetworkDto: LoginDataNetworkDto,
): LoginResultNetworkDto
companion object {
private const val BASE_URL = "http://51.250.107.247:8080"
fun build(): LoginNetworkApi = Retrofit.Builder()
.baseUrl(BASE_URL)
.addConverterFactory(GsonConverterFactory.create())
.build()
.create(LoginNetworkApi::class.java)
}
} | MedAnalytica/data/login-data/src/main/java/ru/pyroman/medanalytica/data/login/network/api/LoginNetworkApi.kt | 233258927 |
package ru.pyroman.medanalytica.data.login.network
import ru.pyroman.medanalytica.data.login.network.dto.LoginDataNetworkDto
import ru.pyroman.medanalytica.domain.login.model.LoginData
class LoginNetworkMapper {
fun map(model: LoginData): LoginDataNetworkDto {
return LoginDataNetworkDto(
login = model.login,
password = model.password,
)
}
} | MedAnalytica/data/login-data/src/main/java/ru/pyroman/medanalytica/data/login/network/LoginNetworkMapper.kt | 2135509339 |
package ru.pyroman.medanalytica.data.start.repository
import ru.pyroman.medanalytica.domain.start.repository.StartRepository
import ru.pyroman.medanalytica.domain.token.repository.TokenRepository
import ru.pyroman.medanalytica.domain.uid.repository.UidRepository
import javax.inject.Inject
class StartRepositoryImpl @Inject internal constructor(
private val uidRepository: UidRepository,
private val tokenRepository: TokenRepository,
) : StartRepository {
override suspend fun isLoggedIn(): Boolean {
val uid = uidRepository.getUid()
val token = tokenRepository.getToken()
return uid != null && token != null
}
} | MedAnalytica/data/start-data/src/main/java/ru/pyroman/medanalytica/data/start/repository/StartRepositoryImpl.kt | 3189324312 |
package ru.pyroman.medanalytica.data.start.di
import dagger.Binds
import dagger.Module
import dagger.Provides
import ru.pyroman.medanalytica.data.start.repository.StartRepositoryImpl
import ru.pyroman.medanalytica.domain.start.repository.StartRepository
import ru.pyroman.medanalytica.domain.token.repository.TokenRepository
import ru.pyroman.medanalytica.domain.uid.repository.UidRepository
@Module
interface StartDataModule {
@Binds
fun bindStartRepository(impl: StartRepositoryImpl): StartRepository
companion object {
@Provides
internal fun provideStartRepositoryImpl(
uidRepository: UidRepository,
tokenRepository: TokenRepository,
): StartRepositoryImpl {
return StartRepositoryImpl(
uidRepository = uidRepository,
tokenRepository = tokenRepository,
)
}
}
} | MedAnalytica/data/start-data/src/main/java/ru/pyroman/medanalytica/data/start/di/StartDataModule.kt | 2566402009 |
package ru.pyroman.medanalytica.domain.profile.repository
import ru.pyroman.medanalytica.domain.profile.domain.ProfileData
interface ProfileRepository {
suspend fun getProfileData(): ProfileData
suspend fun patchProfileData(data: ProfileData)
} | MedAnalytica/domain/profile-domain/src/main/java/ru/pyroman/medanalytica/domain/profile/repository/ProfileRepository.kt | 341370854 |
package ru.pyroman.medanalytica.domain.profile.domain
enum class BloodType(val value: String) {
A_PLUS("A+"),
A_MINUS("A-"),
B_PLUS("B+"),
B_MINUS("B-"),
AB_PLUS("AB+"),
AB_MINUS("AB-"),
O_PLUS("O+"),
O_MINUS("O-");
companion object {
fun fromValue(value: String): BloodType? {
val valueToEnumMap = BloodType.entries
.asSequence()
.map { bloodType ->
bloodType.value to bloodType
}
.toMap()
return valueToEnumMap[value]
}
}
} | MedAnalytica/domain/profile-domain/src/main/java/ru/pyroman/medanalytica/domain/profile/domain/BloodType.kt | 963823300 |
package ru.pyroman.medanalytica.domain.profile.domain
data class ProfileData(
val name: String,
val surname: String,
val dateOfBirth: String,
val weight: Int?,
val height: Int?,
val bloodType: BloodType?,
) | MedAnalytica/domain/profile-domain/src/main/java/ru/pyroman/medanalytica/domain/profile/domain/ProfileData.kt | 214388555 |
package ru.pyroman.medanalytica.domain.start.repository
interface StartRepository {
suspend fun isLoggedIn(): Boolean
} | MedAnalytica/domain/start-domain/src/main/java/ru/pyroman/medanalytica/domain/start/repository/StartRepository.kt | 346271027 |
package ru.pyroman.medanalytica.domain.register.repository
import ru.pyroman.medanalytica.domain.register.model.RegisterData
import ru.pyroman.medanalytica.domain.register.model.RegisterResult
interface RegisterRepository {
suspend fun register(data: RegisterData): RegisterResult
} | MedAnalytica/domain/register-domain/src/main/java/ru/pyroman/medanalytica/domain/register/repository/RegisterRepository.kt | 2858355927 |
package ru.pyroman.medanalytica.domain.register.model
sealed class RegisterResult {
data object Success : RegisterResult()
data class Failure(val message: String) : RegisterResult()
} | MedAnalytica/domain/register-domain/src/main/java/ru/pyroman/medanalytica/domain/register/model/RegisterResult.kt | 3871545488 |
package ru.pyroman.medanalytica.domain.register.model
class RegisterData(
val login: String,
val password: String,
val name: String? = null,
val surname: String? = null,
val dateOfBirth: String? = null,
val weight: Int? = null,
val height: Int? = null,
) | MedAnalytica/domain/register-domain/src/main/java/ru/pyroman/medanalytica/domain/register/model/RegisterData.kt | 1031125257 |
package ru.pyroman.medanalytica.domain.analysisgraph.repository
import ru.pyroman.medanalytica.domain.analysisgraph.model.AnalysisGraphListData
interface AnalysisGraphRepository {
suspend fun fetchGraphList(): AnalysisGraphListData
suspend fun searchGraphs(searchText: String): AnalysisGraphListData
suspend fun clearCache()
} | MedAnalytica/domain/analysis-graph-domain/src/main/java/ru/pyroman/medanalytica/domain/analysisgraph/repository/AnalysisGraphRepository.kt | 1442130572 |
package ru.pyroman.medanalytica.domain.analysisgraph.model
typealias AnalysisGraphList = List<AnalysisGraphData> | MedAnalytica/domain/analysis-graph-domain/src/main/java/ru/pyroman/medanalytica/domain/analysisgraph/model/AnalysisGraphList.kt | 1703413216 |
package ru.pyroman.medanalytica.domain.analysisgraph.model
enum class AnalysisGraphListWarning {
NETWORK_ERROR,
EMPTY,
EMPTY_BY_SEARCH,
} | MedAnalytica/domain/analysis-graph-domain/src/main/java/ru/pyroman/medanalytica/domain/analysisgraph/model/AnalysisGraphListWarning.kt | 3160958149 |
package ru.pyroman.medanalytica.domain.analysisgraph.model
data class AnalysisGraphListData(
val graphs: List<AnalysisGraphData>,
val warning: AnalysisGraphListWarning?,
) | MedAnalytica/domain/analysis-graph-domain/src/main/java/ru/pyroman/medanalytica/domain/analysisgraph/model/AnalysisGraphListData.kt | 3485631500 |
package ru.pyroman.medanalytica.domain.analysisgraph.model
data class AnalysisGraphPoint(
val creationDateTime: String,
val value: Float,
) | MedAnalytica/domain/analysis-graph-domain/src/main/java/ru/pyroman/medanalytica/domain/analysisgraph/model/AnalysisGraphPoint.kt | 3312740228 |
package ru.pyroman.medanalytica.domain.analysisgraph.model
data class AnalysisGraphData(
val analysisType: String,
val units: String,
val points: List<AnalysisGraphPoint>,
) | MedAnalytica/domain/analysis-graph-domain/src/main/java/ru/pyroman/medanalytica/domain/analysisgraph/model/AnalysisGraphData.kt | 3797040785 |
package ru.pyroman.medanalytica.domain.login.repository
import ru.pyroman.medanalytica.domain.login.model.LoginData
import ru.pyroman.medanalytica.domain.login.model.LoginResult
interface LoginRepository {
suspend fun login(data: LoginData): LoginResult
} | MedAnalytica/domain/login-domain/src/main/java/ru/pyroman/medanalytica/domain/login/repository/LoginRepository.kt | 3228320485 |
package ru.pyroman.medanalytica.domain.login.model
class LoginData(
val login: String,
val password: String,
) | MedAnalytica/domain/login-domain/src/main/java/ru/pyroman/medanalytica/domain/login/model/LoginData.kt | 3363141316 |
package ru.pyroman.medanalytica.domain.login.model
sealed class LoginResult {
data object Success : LoginResult()
data class Failure(
val message: String,
) : LoginResult()
} | MedAnalytica/domain/login-domain/src/main/java/ru/pyroman/medanalytica/domain/login/model/LoginResult.kt | 2266578232 |
package ru.pyroman.medanalytica.domain.postanalysis.repository
import ru.pyroman.medanalytica.domain.postanalysis.model.PostAnalysisData
import ru.pyroman.medanalytica.domain.postanalysis.model.PostAnalysisResult
interface PostAnalysisRepository {
suspend fun postAnalysis(data: PostAnalysisData): PostAnalysisResult
} | MedAnalytica/domain/post-analysis-domain/src/main/java/ru/pyroman/medanalytica/domain/postanalysis/repository/PostAnalysisRepository.kt | 1108467699 |
package ru.pyroman.medanalytica.domain.postanalysis.model
class PostAnalysisData(
val file: String,
) | MedAnalytica/domain/post-analysis-domain/src/main/java/ru/pyroman/medanalytica/domain/postanalysis/model/PostAnalysisData.kt | 1584619396 |
package ru.pyroman.medanalytica.domain.postanalysis.model
sealed class PostAnalysisResult {
data object Success : PostAnalysisResult()
data class Error(val message: String) : PostAnalysisResult()
} | MedAnalytica/domain/post-analysis-domain/src/main/java/ru/pyroman/medanalytica/domain/postanalysis/model/PostAnalysisResult.kt | 1052103762 |
package ru.pyroman.medanalytica.domain.token.repository
import ru.pyroman.medanalytica.domain.token.model.Token
interface TokenRepository {
suspend fun setToken(token: Token)
suspend fun getToken(): Token?
suspend fun clearToken()
} | MedAnalytica/domain/token-domain/src/main/java/ru/pyroman/medanalytica/domain/token/repository/TokenRepository.kt | 977326055 |
package ru.pyroman.medanalytica.domain.token.model
typealias Token = String | MedAnalytica/domain/token-domain/src/main/java/ru/pyroman/medanalytica/domain/token/model/Token.kt | 2320363056 |
package ru.pyroman.medanalytica.domain.uid.repository
import ru.pyroman.medanalytica.domain.uid.model.Uid
interface UidRepository {
suspend fun setUid(uid: Uid)
suspend fun getUid(): Uid?
suspend fun clearUid()
} | MedAnalytica/domain/uid-domain/src/main/java/ru/pyroman/medanalytica/domain/uid/repository/UidRepository.kt | 3653462661 |
package ru.pyroman.medanalytica.domain.uid.model
typealias Uid = Long | MedAnalytica/domain/uid-domain/src/main/java/ru/pyroman/medanalytica/domain/uid/model/Uid.kt | 1147922465 |
package ru.pyroman.medanalytica.ui.theme
import androidx.compose.ui.graphics.Color
val Purple80 = Color(0xFFD0BCFF)
val PurpleGrey80 = Color(0xFFCCC2DC)
val Pink80 = Color(0xFFEFB8C8)
val Purple40 = Color(0xFF6650a4)
val PurpleGrey40 = Color(0xFF625b71)
val Pink40 = Color(0xFF7D5260)
val Orange = Color(red = 228, green = 169, blue = 90)
val Red = Color(red = 237, green = 106, blue = 94) | MedAnalytica/base/uikit/src/main/java/ru/pyroman/medanalytica/ui/theme/Color.kt | 2827979798 |
package ru.pyroman.medanalytica.ui.theme
import android.app.Activity
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.platform.LocalView
import androidx.compose.ui.res.colorResource
import androidx.core.view.WindowCompat
import ru.pyroman.medanalytica.base.uikit.R
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
private val LightColorScheme = lightColorScheme(
primary = Purple40,
secondary = PurpleGrey40,
tertiary = Pink40
/* Other default colors to override
background = Color(0xFFFFFBFE),
surface = Color(0xFFFFFBFE),
onPrimary = Color.White,
onSecondary = Color.White,
onTertiary = Color.White,
onBackground = Color(0xFF1C1B1F),
onSurface = Color(0xFF1C1B1F),
*/
)
@Composable
fun MedAnalyticaTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
val colorScheme = LightColorScheme
val view = LocalView.current
if (!view.isInEditMode) {
val statusBarColor = colorResource(R.color.lightBlue).toArgb()
SideEffect {
val window = (view.context as Activity).window
window.statusBarColor = statusBarColor
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} | MedAnalytica/base/uikit/src/main/java/ru/pyroman/medanalytica/ui/theme/Theme.kt | 380471124 |
package ru.pyroman.medanalytica.ui.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
// Set of Material typography styles to start with
val Typography = Typography(
bodyLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp
)
/* Other default text styles to override
titleLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 22.sp,
lineHeight = 28.sp,
letterSpacing = 0.sp
),
labelSmall = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Medium,
fontSize = 11.sp,
lineHeight = 16.sp,
letterSpacing = 0.5.sp
)
*/
) | MedAnalytica/base/uikit/src/main/java/ru/pyroman/medanalytica/ui/theme/Type.kt | 2492718031 |
package ru.pyroman.medanalytica.ui.view
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.TextUnit
import androidx.compose.ui.unit.TextUnitType
import androidx.compose.ui.unit.dp
@Composable
fun StyledTextButton(
modifier: Modifier = Modifier,
contentPadding: PaddingValues = PaddingValues(vertical = 16.dp),
fontSize: TextUnit = TextUnit(20f, TextUnitType.Sp),
fontWeight: FontWeight = FontWeight.Medium,
text: String,
textColor: Color,
color: Color,
onClick: () -> Unit,
) {
Button(
modifier = modifier,
shape = RoundedCornerShape(8.dp),
contentPadding = contentPadding,
onClick = onClick,
colors = ButtonDefaults.buttonColors(color),
) {
Text(
text = text,
color = textColor,
fontSize = fontSize,
fontWeight = fontWeight,
textAlign = TextAlign.Center,
)
}
} | MedAnalytica/base/uikit/src/main/java/ru/pyroman/medanalytica/ui/view/StyledTextButton.kt | 1356451877 |
package ru.pyroman.medanalytica.ui.view
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Warning
import androidx.compose.material3.Icon
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import ru.pyroman.medanalytica.ui.theme.Red
@Composable
fun ErrorView(
modifier: Modifier = Modifier,
text: String,
) {
Row(
modifier = modifier
.clip(RoundedCornerShape(16.dp))
.background(Red)
.padding(8.dp)
.fillMaxWidth(),
verticalAlignment = Alignment.CenterVertically,
) {
Icon(
modifier = Modifier.padding(8.dp),
imageVector = Icons.Default.Warning,
contentDescription = null,
tint = Color.White,
)
Text(
modifier = Modifier.padding(8.dp),
text = text,
fontWeight = FontWeight.Medium,
color = Color.White,
)
}
}
@Preview(showBackground = false)
@Composable
fun ErrorView_Preview() {
WarningView(text = "Ошибка!")
} | MedAnalytica/base/uikit/src/main/java/ru/pyroman/medanalytica/ui/view/ErrorView.kt | 2454691545 |
package ru.pyroman.medanalytica.ui.view
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Warning
import androidx.compose.material3.Icon
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import ru.pyroman.medanalytica.ui.theme.Orange
@Composable
fun WarningView(
text: String,
) {
Row(
modifier = Modifier
.clip(RoundedCornerShape(16.dp))
.background(Orange)
.padding(8.dp)
.fillMaxWidth(),
verticalAlignment = Alignment.CenterVertically,
) {
Icon(
modifier = Modifier.padding(8.dp),
imageVector = Icons.Default.Warning,
contentDescription = null,
tint = Color.White,
)
Text(
modifier = Modifier.padding(8.dp),
text = text,
fontWeight = FontWeight.Medium,
color = Color.White,
)
}
}
@Preview(showBackground = false)
@Composable
fun WarningView_Preview() {
WarningView(text = "Ворнинг ворнинг ворнинг")
} | MedAnalytica/base/uikit/src/main/java/ru/pyroman/medanalytica/ui/view/WarningView.kt | 2918482666 |
package ru.pyroman.medanalytica.ui.view
import androidx.compose.foundation.border
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.BasicTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.colorResource
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.VisualTransformation
import androidx.compose.ui.unit.TextUnit
import androidx.compose.ui.unit.TextUnitType
import androidx.compose.ui.unit.dp
import ru.pyroman.medanalytica.base.uikit.R
@Composable
fun InputView(
modifier: Modifier = Modifier,
inputTextHint: String,
inputText: String = "",
onValueChange: (String) -> Unit,
visualTransformation: VisualTransformation = VisualTransformation.None,
trailingIcon: (@Composable () -> Unit)? = null,
) {
BasicTextField(
value = inputText,
textStyle = TextStyle(
fontSize = TextUnit(20f, TextUnitType.Sp),
fontWeight = FontWeight.Normal,
),
visualTransformation = visualTransformation,
singleLine = true,
onValueChange = onValueChange,
decorationBox = { textField ->
Row(
modifier = modifier
.clip(shape = RoundedCornerShape(8.dp))
.border(
width = 1.dp,
color = colorResource(R.color.gray),
shape = RoundedCornerShape(8.dp),
),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.SpaceBetween,
) {
Box(
modifier = Modifier
.padding(
vertical = 12.dp,
horizontal = 12.dp,
),
contentAlignment = Alignment.CenterStart,
) {
if (inputText.isEmpty()) {
Text(
text = inputTextHint,
fontSize = TextUnit(20f, TextUnitType.Sp),
fontWeight = FontWeight.Normal,
color = Color.Gray,
)
}
textField()
}
if (trailingIcon != null) {
trailingIcon()
}
}
},
)
} | MedAnalytica/base/uikit/src/main/java/ru/pyroman/medanalytica/ui/view/InputView.kt | 1540088737 |
package com.example
import ca.kittle.plugins.configureRouting
import com.example.plugins.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import io.ktor.server.testing.*
import kotlin.test.*
class ApplicationTest {
@Test
fun testRoot() =
testApplication {
application {
configureRouting()
}
client.get("/").apply {
assertEquals(HttpStatusCode.OK, status)
assertEquals("Hello World!", bodyAsText())
}
}
}
| htmx-poc/src/test/kotlin/com/example/ApplicationTest.kt | 1373228922 |
@file:Suppress("ktlint:standard:no-wildcard-imports")
package ca.kittle
import ca.kittle.plugins.*
import io.ktor.server.application.*
import io.ktor.server.engine.*
import io.ktor.server.netty.*
fun main() {
embeddedServer(Netty, port = 8080, host = "0.0.0.0", module = Application::module)
.start(wait = true)
}
fun Application.module() {
// Create a websocket for the chat example
configureSockets()
// Content will be returned as json, by detail, from routes
configureSerialization()
// Configure simple call logging
configureMonitoring()
// Configure CORS and compression
configureHTTP()
// Sample OAuth and JWT security
configureSecurity()
// Configure routes
configureRouting()
}
| htmx-poc/src/main/kotlin/ca/kittle/Application.kt | 656433885 |
package util
import kotlinx.html.Entities
import kotlinx.html.FlowContent
import kotlinx.html.HtmlBlockTag
import kotlinx.html.HtmlTagMarker
import kotlinx.html.Tag
import kotlinx.html.TagConsumer
import kotlinx.html.Unsafe
import kotlinx.html.consumers.delayed
import kotlinx.html.org.w3c.dom.events.Event
import kotlinx.html.stream.HTMLStreamBuilder
import kotlinx.html.visitAndFinalize
fun <O : Appendable> O.withHTML(prettyPrint: Boolean = true, xhtmlCompatible: Boolean = false): TagConsumer<O> =
CustomHTMLStreamBuilder(this, prettyPrint, xhtmlCompatible).delayed()
@HtmlTagMarker
inline fun <T, C : TagConsumer<T>> C.with(
crossinline block: FlowContent.() -> Unit = {},
): T = EMPTY(this).visitAndFinalize(this, block)
@Suppress("unused")
open class EMPTY(override val consumer: TagConsumer<*>) :
HtmlBlockTag {
override val attributes: MutableMap<String, String> = mutableMapOf()
override val attributesEntries: Collection<Map.Entry<String, String>> = mutableListOf()
override val emptyTag = true
override val inlineTag = false
override val namespace = ""
override val tagName = ""
}
private class CustomHTMLStreamBuilder<out O : Appendable>(
out: O,
prettyPrint: Boolean,
xhtmlCompatible: Boolean,
) :
TagConsumer<O> {
private val streamBuilder = HTMLStreamBuilder<O>(out, prettyPrint, xhtmlCompatible)
override fun finalize(): O {
return streamBuilder.finalize()
}
override fun onTagAttributeChange(tag: Tag, attribute: String, value: String?) {
if (tag is EMPTY) return
return streamBuilder.onTagAttributeChange(tag, attribute, value)
}
override fun onTagComment(content: CharSequence) {
return streamBuilder.onTagComment(content)
}
override fun onTagContent(content: CharSequence) {
return streamBuilder.onTagContent(content)
}
override fun onTagContentEntity(entity: Entities) {
return streamBuilder.onTagContentEntity(entity)
}
override fun onTagContentUnsafe(block: Unsafe.() -> Unit) {
return streamBuilder.onTagContentUnsafe(block)
}
override fun onTagEnd(tag: Tag) {
if (tag is EMPTY) return
return streamBuilder.onTagEnd(tag)
}
override fun onTagEvent(tag: Tag, event: String, value: (Event) -> Unit) {
if (tag is EMPTY) return
return streamBuilder.onTagEvent(tag, event, value)
}
override fun onTagStart(tag: Tag) {
if (tag is EMPTY) return
return streamBuilder.onTagStart(tag)
}
}
| htmx-poc/src/main/kotlin/ca/kittle/util/custom-ktor-html.kt | 539195516 |
@file:Suppress("ktlint:standard:no-wildcard-imports")
package ca.kittle.plugins
import io.ktor.http.*
import io.ktor.server.application.*
import io.ktor.server.plugins.compression.*
import io.ktor.server.plugins.cors.routing.*
fun Application.configureHTTP() {
install(CORS) {
allowMethod(HttpMethod.Options)
allowMethod(HttpMethod.Put)
allowMethod(HttpMethod.Delete)
allowMethod(HttpMethod.Patch)
allowHeader(HttpHeaders.Authorization)
allowHeader("MyCustomHeader")
anyHost() // @TODO: Don't do this in production if possible. Try to limit it.
}
install(Compression) {
gzip {
priority = 1.0
}
deflate {
priority = 10.0
minimumSize(1024) // condition
}
}
}
| htmx-poc/src/main/kotlin/ca/kittle/plugins/HTTP.kt | 1097749952 |
@file:Suppress("ktlint:standard:no-wildcard-imports")
package ca.kittle.plugins
import ca.kittle.routing.*
import io.ktor.server.application.*
import io.ktor.server.routing.*
fun Application.configureRouting() {
routing {
index()
tabs()
multiSelect()
animation()
loading()
chat()
}
}
| htmx-poc/src/main/kotlin/ca/kittle/plugins/Routing.kt | 1463450977 |
@file:Suppress("ktlint:standard:no-wildcard-imports")
package ca.kittle.plugins
import io.ktor.serialization.kotlinx.json.*
import io.ktor.server.application.*
import io.ktor.server.plugins.contentnegotiation.*
import io.ktor.server.response.*
import io.ktor.server.routing.*
fun Application.configureSerialization() {
install(ContentNegotiation) {
json()
}
routing {
get("/json/kotlinx-serialization") {
call.respond(mapOf("hello" to "world"))
}
}
}
| htmx-poc/src/main/kotlin/ca/kittle/plugins/Serialization.kt | 650744147 |
@file:Suppress("ktlint:standard:no-wildcard-imports")
package ca.kittle.plugins
import io.ktor.server.application.*
import io.ktor.server.routing.*
import io.ktor.server.websocket.*
import io.ktor.websocket.*
import java.time.Duration
fun Application.configureSockets() {
install(WebSockets) {
pingPeriod = Duration.ofSeconds(15)
timeout = Duration.ofSeconds(15)
maxFrameSize = Long.MAX_VALUE
masking = false
}
routing {
webSocket("/ws") { // websocketSession
for (frame in incoming) {
if (frame is Frame.Text) {
val text = frame.readText()
outgoing.send(Frame.Text("YOU SAID: $text"))
if (text.equals("bye", ignoreCase = true)) {
close(CloseReason(CloseReason.Codes.NORMAL, "Client said BYE"))
}
}
}
}
}
}
| htmx-poc/src/main/kotlin/ca/kittle/plugins/Sockets.kt | 3016649629 |
@file:Suppress("ktlint:standard:no-wildcard-imports")
package ca.kittle.plugins
import io.ktor.http.*
import io.ktor.server.application.*
import io.ktor.server.plugins.callid.*
import io.ktor.server.plugins.callloging.*
import io.ktor.server.request.*
import org.slf4j.event.Level
fun Application.configureMonitoring() {
install(CallLogging) {
level = Level.INFO
filter { call -> call.request.path().startsWith("/") }
callIdMdc("call-id")
}
install(CallId) {
header(HttpHeaders.XRequestId)
verify { callId: String ->
callId.isNotEmpty()
}
}
}
| htmx-poc/src/main/kotlin/ca/kittle/plugins/Monitoring.kt | 758430141 |
@file:Suppress("ktlint:standard:no-wildcard-imports")
package ca.kittle.plugins
import com.auth0.jwt.JWT
import com.auth0.jwt.algorithms.Algorithm
import io.ktor.client.*
import io.ktor.client.engine.apache.*
import io.ktor.http.*
import io.ktor.server.application.*
import io.ktor.server.auth.*
import io.ktor.server.auth.jwt.*
import io.ktor.server.response.*
import io.ktor.server.routing.*
import io.ktor.server.sessions.*
fun Application.configureSecurity() {
data class MySession(val count: Int = 0)
install(Sessions) {
cookie<MySession>("MY_SESSION") {
cookie.extensions["SameSite"] = "lax"
}
}
// Please read the jwt property from the config file if you are using EngineMain
val jwtAudience = "jwt-audience"
val jwtDomain = "https://jwt-provider-domain/"
val jwtRealm = "ktor sample app"
val jwtSecret = "secret"
authentication {
jwt {
realm = jwtRealm
verifier(
JWT
.require(Algorithm.HMAC256(jwtSecret))
.withAudience(jwtAudience)
.withIssuer(jwtDomain)
.build(),
)
validate { credential ->
if (credential.payload.audience.contains(jwtAudience)) JWTPrincipal(credential.payload) else null
}
}
}
authentication {
oauth("auth-oauth-google") {
urlProvider = { "http://localhost:8080/callback" }
providerLookup = {
OAuthServerSettings.OAuth2ServerSettings(
name = "google",
authorizeUrl = "https://accounts.google.com/o/oauth2/auth",
accessTokenUrl = "https://accounts.google.com/o/oauth2/token",
requestMethod = HttpMethod.Post,
clientId = System.getenv("GOOGLE_CLIENT_ID"),
clientSecret = System.getenv("GOOGLE_CLIENT_SECRET"),
defaultScopes = listOf("https://www.googleapis.com/auth/userinfo.profile"),
)
}
client = HttpClient(Apache)
}
}
routing {
get("/session/increment") {
val session = call.sessions.get<MySession>() ?: MySession()
call.sessions.set(session.copy(count = session.count + 1))
call.respondText("Counter is ${session.count}. Refresh to increment.")
}
authenticate("auth-oauth-google") {
get("login") {
call.respondRedirect("/callback")
}
get("/callback") {
val principal: OAuthAccessTokenResponse.OAuth2? = call.authentication.principal()
call.sessions.set(UserSession(principal?.accessToken.toString()))
call.respondRedirect("/hello")
}
}
}
}
class UserSession(accessToken: String)
| htmx-poc/src/main/kotlin/ca/kittle/plugins/Security.kt | 1357431184 |
package ca.kittle.models
data class Message(
val message: String,
val sent: Boolean,
)
data class Person(
val name: String,
val email: String,
val role: String,
val imageUrl: String,
val lastSeen: String?,
val lastSeenDateTime: String? = null,
)
| htmx-poc/src/main/kotlin/ca/kittle/models/ApplicationModels.kt | 2324781643 |
@file:Suppress("ktlint:standard:no-wildcard-imports")
package ca.kittle.components
import ca.kittle.models.Message
import kotlinx.html.*
fun FlowContent.chatPage() =
div {
header {
classes = setOf("bg-white", "shadow")
div {
classes = setOf("mx-auto", "max-w-7xl", "px-4", "py-6", "sm:px-6", "lg:px-8")
h1 {
classes = setOf("text-3xl", "font-bold", "tracking-tight", "text-gray-900")
+"Chat"
}
}
}
main {
div {
attributes["hx-ws"] = "connect:/content/chat/ws"
classes = setOf("mx-auto", "max-w-7xl", "py-6", "sm:px-6", "lg:px-8")
// This div matches the id of the div returned by the
// Websocket, so it will be replaced
chatMessages(listOf())
// Input submits form as JSON to the websocket
form {
attributes["hx-ws"] = "send:submit"
chatInput()
}
}
}
}
fun FlowContent.chatMessages(messages: List<Message>) =
div {
id = "messages"
messages.map {
p {
classes = setOf(
"rounded-md",
"my-2",
"w-full",
"px-4",
"py-2",
) + if (it.sent) "bg-blue-200" else "bg-neutral-200"
+it.message
}
}
}
fun FlowContent.chatInput() =
input {
id = "input"
name = "message"
type = InputType.text
classes = setOf("w-full", "h-8", "border-2", "border-neutral-200", "rounded-md")
value = ""
autoFocus = true
}
| htmx-poc/src/main/kotlin/ca/kittle/components/ChatPage.kt | 2461020616 |
@file:Suppress("ktlint:standard:no-wildcard-imports")
package ca.kittle.components
import kotlinx.html.*
fun FlowContent.navigation() {
// List of tabs
val tabs =
listOf(
Tab("Tabs", "/content/empty"),
Tab("Input updates a separate component", "/content/multi-select"),
Tab("Animation", "/content/animation"),
Tab("Asynchronous Loading", "/content/loading"),
Tab("Chat", "/content/chat"),
)
div {
classes = setOf("min-h-full")
nav {
classes = setOf("bg-gray-800")
div {
classes = setOf("mx-auto", "max-w-7xl", "px-4", "sm:px-6", "lg:px-8")
div {
classes = setOf("flex", "h-16", "items-center", "justify-between")
div {
classes = setOf("flex", "items-center")
div {
classes = setOf("flex-shrink-0")
img {
classes = setOf("h-8", "w-8")
src = "https://tailwindui.com/img/logos/mark.svg?color=indigo&shade=500"
alt = "Your Company"
}
}
div {
classes = setOf("hidden", "md:block")
div {
classes = setOf("ml-10", "flex", "items-baseline", "space-x-4")
tabs.map {
a {
// Fetch from the URL and update the content div
attributes["hx-get"] = it.url
attributes["hx-target"] = "#content"
classes =
setOf(
"text-gray-300",
"hover:bg-gray-700",
"hover:text-white",
"rounded-md",
"px-3",
"py-2",
"text-sm",
"font-medium",
)
+it.name
}
}
}
}
}
}
}
}
div {
// ID of "content" is used to switch the page
id = "content"
emptyTabPage()
}
}
}
private data class Tab(
val name: String,
val url: String,
)
| htmx-poc/src/main/kotlin/ca/kittle/components/Navigation.kt | 985614528 |
@file:Suppress("ktlint:standard:no-wildcard-imports")
package ca.kittle.components
import kotlinx.html.*
fun FlowContent.emptyTabPage() =
div {
header {
classes = setOf("bg-white", "shadow")
div {
classes = setOf("mx-auto", "max-w-7xl", "px-4", "py-6", "sm:px-6", "lg:px-8")
h1 {
classes = setOf("text-3xl", "font-bold", "tracking-tight", "text-gray-900")
+"Tabs"
}
}
}
main {
div {
classes = setOf("mx-auto", "max-w-7xl", "py-6", "sm:px-6", "lg:px-8")
}
}
}
| htmx-poc/src/main/kotlin/ca/kittle/components/TabsPage.kt | 674623784 |
@file:Suppress("ktlint:standard:no-wildcard-imports")
package ca.kittle.components
import ca.kittle.models.Person
import ca.kittle.services.PeopleService
import kotlinx.html.*
fun FlowContent.companyDirectoryPage(
nameEnabled: Boolean = true,
emailEnabled: Boolean = true,
lastOnlineEnabled: Boolean = true,
) = div {
// List of people
val people = PeopleService.getPeople()
header {
classes = setOf("bg-white", "shadow")
div {
classes = setOf("mx-auto", "max-w-7xl", "px-4", "py-6", "sm:px-6", "lg:px-8")
h1 {
classes = setOf("text-3xl", "font-bold", "tracking-tight", "text-gray-900")
+"Input updates a separate component"
}
}
}
main {
div {
classes = setOf("mx-auto", "max-w-7xl", "py-6", "sm:px-6", "lg:px-8")
// Inputs post a form request with the updated values
// Response updates the whole content div
div {
personDataFilter(nameEnabled, emailEnabled, lastOnlineEnabled)
people(people, nameEnabled, emailEnabled, lastOnlineEnabled)
}
}
}
}
private fun FlowContent.personDataFilter(
nameEnabled: Boolean,
emailEnabled: Boolean,
lastOnlineEnabled: Boolean,
) = form {
classes = setOf("max-w-sm", "mx-auto", "my-4", "gap-2")
input {
attributes["hx-post"] = "/content/multi-select/table/name/$nameEnabled"
attributes["hx-target"] = "#content"
id = "name"
type = InputType.checkBox
name = "name"
value = nameEnabled.toString()
checked = nameEnabled
}
label {
htmlFor = "multi-select"
+" Name"
}
br { }
input {
attributes["hx-post"] = "/content/multi-select/table/email/$emailEnabled"
attributes["hx-target"] = "#content"
id = "email"
type = InputType.checkBox
name = "email"
value = emailEnabled.toString()
checked = emailEnabled
}
label {
htmlFor = "email"
+" Email"
}
br { }
input {
attributes["hx-post"] = "/content/multi-select/table/last-online/$lastOnlineEnabled"
attributes["hx-target"] = "#content"
id = "last-online"
type = InputType.checkBox
name = "last-online"
value = lastOnlineEnabled.toString()
checked = lastOnlineEnabled
}
label {
htmlFor = "last-online"
+" Last Online"
}
br { }
}
private fun FlowContent.people(
people: List<Person>,
nameEnabled: Boolean,
emailEnabled: Boolean,
lastOnlineEnabled: Boolean,
) = ul {
role = "list"
classes = setOf("divide-y", "divide-gray-100")
people.map { person ->
li {
classes = setOf("flex", "justify-between", "gap-x-6", "py-5")
div {
classes = setOf("flex", "min-w-0", "gap-x-4")
img {
classes = setOf("h-12", "w-12", "flex-none", "rounded-full", "bg-gray-50")
src = person.imageUrl
alt = ""
}
div {
classes = setOf("min-w-0", "flex-auto")
// Conditional rendering
if (nameEnabled) {
p {
classes = setOf("text-sm", "font-semibold", "leading-6", "text-gray-900")
+person.name
}
}
if (emailEnabled) {
p {
classes = setOf("mt-1", "truncate", "text-xs", "leading-5", "text-gray-500")
+person.email
}
}
}
}
div {
classes = setOf("hidden", "shrink-0", "sm:flex", "sm:flex-col", "sm:items-end")
p {
classes = setOf("text-sm", "leading-6", "text-gray-900")
+person.role
}
if (lastOnlineEnabled) {
if (person.lastSeenDateTime != null && person.lastSeen != null) {
p {
classes = setOf("mt-1", "text-xs", "leading-5", "text-gray-500")
+"Last seen "
time {
attributes["datetime"] = person.lastSeenDateTime
+person.lastSeen
}
}
} else {
div {
classes = setOf("mt-1", "flex", "items-center", "gap-x-1.5")
div {
classes = setOf("flex-none", "rounded-full", "bg-emerald-500/20", "p-1")
div {
classes = setOf("h-1.5", "w-1.5", "rounded-full", "bg-emerald-500")
}
}
p {
classes = setOf("text-xs", "leading-5", "text-gray-500")
+"Online"
}
}
}
}
}
}
}
}
| htmx-poc/src/main/kotlin/ca/kittle/components/CompanyDirectoryPage.kt | 757390951 |
package ca.kittle.routing
import io.ktor.server.application.call
import io.ktor.server.html.respondHtml
import io.ktor.server.routing.Routing
import io.ktor.server.routing.get
import kotlinx.html.FlowContent
import kotlinx.html.body
import kotlinx.html.classes
import kotlinx.html.div
import kotlinx.html.h1
import kotlinx.html.header
import kotlinx.html.id
import kotlinx.html.main
import kotlinx.html.p
import kotlinx.html.style
fun Routing.loading() {
get("/content/loading") {
call.respondHtml {
body {
loading()
}
}
}
var percentage = 0
get("/content/loading/status") {
call.respondHtml {
body {
percentage += 5
if (percentage > 100) percentage = 0
// Return updated loading bar
div {
id = "loading-bar"
attributes["hx-get"] = "/content/loading/status"
attributes["hx-trigger"] = "load delay:300ms"
attributes["hx-swap"] = "outerHTML"
classes = setOf("bg-blue-300", "h-32", "rounded-md", "transition-all")
style = "width: $percentage%"
}
}
}
}
}
private fun FlowContent.loading() =
div {
header {
classes = setOf("bg-white", "shadow")
div {
classes = setOf("mx-auto", "max-w-7xl", "px-4", "py-6", "sm:px-6", "lg:px-8")
h1 {
classes = setOf("text-3xl", "font-bold", "tracking-tight", "text-gray-900")
+"Loading"
}
}
}
main {
classes = setOf("mx-auto", "max-w-7xl", "py-6", "sm:px-6", "lg:px-8", "flex", "gap-4", "flex-col")
p { +"Progress..." }
div {
// Poll endpoint, which updates itself with the response
id = "loading-bar"
attributes["hx-get"] = "/content/loading/status"
attributes["hx-trigger"] = "load delay:300ms"
attributes["hx-swap"] = "outerHTML"
classes = setOf("bg-blue-300", "h-32", "rounded-md", "transition-all")
style = "width: 0%"
}
}
}
| htmx-poc/src/main/kotlin/ca/kittle/routing/4-loading.kt | 2822015255 |
package ca.kittle.routing
import ca.kittle.components.navigation
import io.ktor.server.application.*
import io.ktor.server.html.*
import io.ktor.server.http.content.*
import io.ktor.server.routing.*
import kotlinx.html.body
import kotlinx.html.head
import kotlinx.html.script
fun Routing.index() {
get {
call.respondHtml {
head {
script {
// src = "https://unpkg.com/[email protected]"
src = "static/assets/htmx.min.js"
}
script {
// src = "https://cdn.tailwindcss.com"
src = "static/assets/tailwind.js"
}
}
body {
navigation()
}
}
}
static("/static") {
resources("static")
}
}
| htmx-poc/src/main/kotlin/ca/kittle/routing/0-index.kt | 3746352086 |
@file:Suppress("ktlint:standard:filename")
package ca.kittle.routing
import ca.kittle.components.chatInput
import ca.kittle.components.chatMessages
import ca.kittle.components.chatPage
import ca.kittle.models.Message
import io.ktor.server.application.call
import io.ktor.server.html.respondHtml
import io.ktor.server.routing.Routing
import io.ktor.server.routing.get
import io.ktor.server.websocket.webSocket
import io.ktor.utils.io.core.buildPacket
import io.ktor.websocket.Frame
import io.ktor.websocket.readText
import kotlinx.html.body
import kotlinx.html.div
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import util.with
import util.withHTML
import kotlin.random.Random
fun Routing.chat() {
get("/content/chat") {
call.respondHtml {
body {
chatPage()
}
}
}
@Serializable
data class Payload(val message: String)
val json =
Json {
ignoreUnknownKeys = true
}
webSocket("/content/chat/ws") {
val messages = mutableListOf<Message>()
for (frame in incoming) {
frame as? Frame.Text ?: continue
val data = frame.readText()
val payload = json.decodeFromString<Payload>(data)
val output =
payload.message.map { if (Random.nextBoolean()) it.uppercase() else it.lowercase() }.joinToString("")
messages += Message(payload.message, true)
messages += Message(output, false)
val response =
buildPacket {
// Websocket replies with updated list of messages
withHTML().with {
chatMessages(messages.toList())
chatInput()
}
}.readText()
send(Frame.Text(response))
}
}
}
| htmx-poc/src/main/kotlin/ca/kittle/routing/5-chat.kt | 610721293 |
package ca.kittle.routing
import io.ktor.server.application.call
import io.ktor.server.html.respondHtml
import io.ktor.server.routing.Routing
import io.ktor.server.routing.get
import kotlinx.html.ButtonType
import kotlinx.html.FlowContent
import kotlinx.html.body
import kotlinx.html.button
import kotlinx.html.classes
import kotlinx.html.div
import kotlinx.html.h1
import kotlinx.html.header
import kotlinx.html.id
import kotlinx.html.main
fun Routing.animation() {
get("/content/animation") {
call.respondHtml {
body {
animation("circle")
}
}
}
get("/content/animation/{shape}") {
val shape = call.parameters["shape"] ?: "circle"
call.respondHtml {
body {
animation(shape)
}
}
}
}
private fun FlowContent.animation(shape: String) =
div {
header {
classes = setOf("bg-white", "shadow")
div {
classes = setOf("mx-auto", "max-w-7xl", "px-4", "py-6", "sm:px-6", "lg:px-8")
h1 {
classes = setOf("text-3xl", "font-bold", "tracking-tight", "text-gray-900")
+"Animation"
}
}
}
main {
classes = setOf("mx-auto", "max-w-7xl", "py-6", "sm:px-6", "lg:px-8", "flex", "gap-4", "flex-col")
// Render whichever shape is selected
// CSS animations apply as normal
// But id must be consistent
if (shape == "circle") {
div {
id = "animation-object"
classes = setOf("rounded-full", "w-32", "h-32", "bg-red-600", "transition-all", "duration-500")
}
} else {
div {
id = "animation-object"
classes = setOf("w-full", "h-32", "bg-blue-600", "rounded-md", "transition-all", "duration-500")
}
}
button {
// Button makes a request for the other shape
// Replaces the whole div
val otherShape = if (shape == "circle") "rectangle" else "circle"
attributes["hx-get"] = "/content/animation/$otherShape"
attributes["hx-target"] = "#content"
type = ButtonType.button
classes =
setOf(
"text-white",
"bg-blue-700",
"hover:bg-blue-800",
"focus:ring-4",
"focus:ring-blue-300",
"font-medium",
"rounded-lg",
"text-sm",
"px-5",
"py-2.5",
"me-2",
"mb-2",
"dark:bg-blue-600",
"dark:hover:bg-blue-700",
"focus:outline-none",
"dark:focus:ring-blue-800",
)
+"Click Me"
}
}
}
| htmx-poc/src/main/kotlin/ca/kittle/routing/3-animation.kt | 1590635178 |
package ca.kittle.routing
import ca.kittle.components.companyDirectoryPage
import io.ktor.server.application.call
import io.ktor.server.html.respondHtml
import io.ktor.server.request.receiveParameters
import io.ktor.server.routing.Routing
import io.ktor.server.routing.get
import io.ktor.server.routing.post
import kotlinx.html.body
import kotlinx.html.div
fun Routing.multiSelect() {
get("/content/multi-select") {
call.respondHtml {
body {
companyDirectoryPage()
}
}
}
post("/content/multi-select/table/{attribute}/{enabled}") {
val attribute = call.parameters["attribute"]
val enabled = call.parameters["enabled"].toBoolean()
val parameters = call.receiveParameters()
val name = if (attribute == "name") !enabled else parameters["name"].toBoolean()
val email = if (attribute == "email") !enabled else parameters["email"].toBoolean()
val lastOnline = if (attribute == "last-online") !enabled else parameters["last-online"].toBoolean()
call.respondHtml {
body {
companyDirectoryPage(name, email, lastOnline)
}
}
}
}
| htmx-poc/src/main/kotlin/ca/kittle/routing/2-multi-select.kt | 1066572782 |
package ca.kittle.routing
import ca.kittle.components.emptyTabPage
import io.ktor.server.application.call
import io.ktor.server.html.respondHtml
import io.ktor.server.routing.Routing
import io.ktor.server.routing.get
import kotlinx.html.body
import kotlinx.html.div
import kotlin.collections.set
fun Routing.tabs() {
get("/content/empty") {
call.respondHtml {
body {
emptyTabPage()
}
}
}
}
| htmx-poc/src/main/kotlin/ca/kittle/routing/1-tabs.kt | 3686983253 |
package ca.kittle.services
import ca.kittle.models.Person
object PeopleService {
fun getPeople(): List<Person> =
listOf(
Person(
"Leslie Alexander",
"[email protected]",
"Co-Founder / CEO",
"https://images.unsplash.com/photo-1494790108377-be9c29b29330?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=facearea&facepad=2&w=256&h=256&q=80",
"3h ago",
"2023-01-23T13:23Z",
),
Person(
"Michael Foster",
"[email protected]",
"Co-Founder / CTO",
"https://images.unsplash.com/photo-1519244703995-f4e0f30006d5?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=facearea&facepad=2&w=256&h=256&q=80",
"3h ago",
"2023-01-23T13:23Z",
),
Person(
"Dries Vincent",
"[email protected]",
"Business Relations",
"https://images.unsplash.com/photo-1506794778202-cad84cf45f1d?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=facearea&facepad=2&w=256&h=256&q=80",
null,
),
Person(
"Lindsay Walton",
"[email protected]",
"Front-end Developer",
"https://images.unsplash.com/photo-1517841905240-472988babdf9?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=facearea&facepad=2&w=256&h=256&q=80",
"3h ago",
"2023-01-23T13:23Z",
),
Person(
"Courtney Henry",
"[email protected]",
"Designer",
"https://images.unsplash.com/photo-1438761681033-6461ffad8d80?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=facearea&facepad=2&w=256&h=256&q=80",
"3h ago",
"2023-01-23T13:23Z",
),
Person(
"Tom Cook",
"[email protected]",
"Director of Product",
"https://images.unsplash.com/photo-1472099645785-5658abf4ff4e?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=facearea&facepad=2&w=256&h=256&q=80",
null,
),
)
}
| htmx-poc/src/main/kotlin/ca/kittle/services/PeopleService.kt | 1672396809 |
package com.example.cleanarchcrypto.di
import com.example.cleanarchcrypto.common.Constants
import com.example.cleanarchcrypto.data.remote.CoinPaprikaApi
import com.example.cleanarchcrypto.data.repository.CoinRepositoryImpl
import com.example.cleanarchcrypto.domain.repository.CoinRepository
import com.example.cleanarchcrypto.domain.use_case.get_coin.GetCoinUseCase
import com.example.cleanarchcrypto.domain.use_case.get_coins.GetCoinsUseCase
import com.example.cleanarchcrypto.domain.use_case.interfaces.IGetCoinUseCase
import com.example.cleanarchcrypto.domain.use_case.interfaces.IGetCoinsUseCase
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.scopes.ViewModelScoped
import dagger.hilt.components.SingletonComponent
import kotlinx.coroutines.DelicateCoroutinesApi
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory
import javax.inject.Singleton
import okhttp3.mockwebserver.MockWebServer
@Module
@InstallIn(SingletonComponent::class)
object TestAppModule {
@OptIn(DelicateCoroutinesApi::class)
@Provides
@Singleton
fun providePaprikaApi(): CoinPaprikaApi = runBlocking(Dispatchers.IO) {
val server = MockWebServer()
server.start()
Retrofit.Builder().baseUrl(server.url("/"))
.addConverterFactory(GsonConverterFactory.create()).build()
.create(CoinPaprikaApi::class.java)
}
@Provides
@Singleton
fun provideCoinRepository(api: CoinPaprikaApi): CoinRepository {
return CoinRepositoryImpl(api)
}
} | CleanArchJetpackCompose/app/src/androidTest/java/com/example/cleanarchcrypto/di/TestAppModule.kt | 2448886601 |
package com.example.cleanarchcrypto
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.example.cleanarchcrypto", appContext.packageName)
}
} | CleanArchJetpackCompose/app/src/androidTest/java/com/example/cleanarchcrypto/ExampleInstrumentedTest.kt | 3613002445 |
package com.example.cleanarchcrypto.util
object MockObject {
val mockCoinListJson = """[
{
"id": "btc-bitcoin",
"name": "Bitcoin",
"symbol": "BTC",
"rank": 1,
"is_new": false,
"is_active": true,
"type": "coin"
},
{
"id": "eth-ethereum",
"name": "Ethereum",
"symbol": "ETH",
"rank": 2,
"is_new": false,
"is_active": true,
"type": "coin"
},
{
"id": "usdt-tether",
"name": "Tether",
"symbol": "USDT",
"rank": 3,
"is_new": false,
"is_active": true,
"type": "token"
}
}"""
val mockCoinDetail = """
{
"id": "btc-bitcoin",
"name": "Bitcoin",
"symbol": "BTC",
"rank": 1,
"is_new": false,
"is_active": true,
"type": "coin",
"logo": "https://static.coinpaprika.com/coin/btc-bitcoin/logo.png",
"tags": [
{
"id": "segwit",
"name": "Segwit",
"coin_counter": 10,
"ico_counter": 0
},
{
"id": "cryptocurrency",
"name": "Cryptocurrency",
"coin_counter": 1073,
"ico_counter": 40
},
{
"id": "proof-of-work",
"name": "Proof Of Work",
"coin_counter": 519,
"ico_counter": 14
},
{
"id": "payments",
"name": "Payments",
"coin_counter": 169,
"ico_counter": 39
},
{
"id": "sha256",
"name": "Sha256",
"coin_counter": 47,
"ico_counter": 1
},
{
"id": "mining",
"name": "Mining",
"coin_counter": 272,
"ico_counter": 18
},
{
"id": "lightning-network",
"name": "Lightning Network",
"coin_counter": 6,
"ico_counter": 0
}
],
"team": [
{
"id": "satoshi-nakamoto",
"name": "Satoshi Nakamoto",
"position": "Founder"
},
{
"id": "wladimir-j-van-der-laan",
"name": "Wladimir J. van der Laan",
"position": "Blockchain Developer"
},
{
"id": "jonas-schnelli",
"name": "Jonas Schnelli",
"position": "Blockchain Developer"
},
{
"id": "marco-falke",
"name": "Marco Falke",
"position": "Blockchain Developer"
},
{
"id": "rahul",
"name": "Rahul",
"position": "Node js Developer"
},
{
"id": "ashutosh",
"name": "Ashutosh",
"position": "Whale Miner"
},
{
"id": "turd-fergason",
"name": "Turd Fergason",
"position": "Blockchain Devolper"
}
],
"description": "Bitcoin is a cryptocurrency and worldwide payment system. It is the first decentralized digital currency, as the system works without a central bank or single administrator.",
"message": "",
"open_source": true,
"started_at": "2009-01-03T00:00:00Z",
"development_status": "Working product",
"hardware_wallet": true,
"proof_type": "Proof of Work",
"org_structure": "Decentralized",
"hash_algorithm": "SHA256",
"links": {
"explorer": [
"https://blockchair.com/bitcoin/?from=coinpaprika",
"https://blockchain.com/explorer",
"https://blockstream.info/",
"https://live.blockcypher.com/btc/",
"https://btc.cryptoid.info/btc/"
],
"facebook": [
"https://www.facebook.com/bitcoins/"
],
"reddit": [
"https://www.reddit.com/r/bitcoin"
],
"source_code": [
"https://github.com/bitcoin/bitcoin"
],
"website": [
"https://bitcoin.org/"
],
"youtube": [
"https://www.youtube.com/watch?v=Gc2en3nHxA4&"
]
},
"links_extended": [
{
"url": "https://bitcoin.org/en/blog",
"type": "blog"
},
{
"url": "https://blockchair.com/bitcoin/?from=coinpaprika",
"type": "explorer"
},
{
"url": "https://blockchain.com/explorer",
"type": "explorer"
},
{
"url": "https://blockstream.info/",
"type": "explorer"
},
{
"url": "https://live.blockcypher.com/btc/",
"type": "explorer"
},
{
"url": "https://btc.cryptoid.info/btc/",
"type": "explorer"
},
{
"url": "https://www.facebook.com/bitcoins/",
"type": "facebook"
},
{
"url": "https://bitcointalk.org",
"type": "message_board"
},
{
"url": "https://www.reddit.com/r/bitcoin",
"type": "reddit",
"stats": {
"subscribers": 5958815
}
},
{
"url": "https://github.com/bitcoin/bitcoin",
"type": "source_code",
"stats": {
"contributors": 1164,
"stars": 73576
}
},
{
"url": "https://twitter.com/bitcoincoreorg",
"type": "twitter",
"stats": {
"followers": 161310
}
},
{
"url": "https://electrum.org/#download",
"type": "wallet"
},
{
"url": "https://bitcoin.org/",
"type": "website"
},
{
"url": "https://www.youtube.com/watch?v=Gc2en3nHxA4&",
"type": "youtube"
}
],
"whitepaper": {
"link": "https://static.coinpaprika.com/storage/cdn/whitepapers/215.pdf",
"thumbnail": "https://static.coinpaprika.com/storage/cdn/whitepapers/217.jpg"
},
"first_data_at": "2010-07-17T00:00:00Z",
"last_data_at": "2024-01-29T02:10:00Z"
}
"""
} | CleanArchJetpackCompose/app/src/androidTest/java/com/example/cleanarchcrypto/util/MockObject.kt | 3338605302 |
package com.example.cleanarchcrypto.util
import com.example.cleanarchcrypto.FakeObjects
import com.example.cleanarchcrypto.data.remote.dto.CoinDetailDto
import com.example.cleanarchcrypto.data.remote.dto.CoinDto
import com.example.cleanarchcrypto.domain.repository.CoinRepository
class FakeCoinRepository : CoinRepository {
override suspend fun getCoins(): List<CoinDto> {
// Generate and return fake list of CoinDto
return FakeObjects.mockCoinList
}
override suspend fun getCoinById(coinId: String): CoinDetailDto {
// Generate and return a fake CoinDetailDto based on the coinId
return when (coinId) {
"btc" -> FakeObjects.mockCoinDetail // Add more dummy data for other coinIds as needed
else -> throw IllegalArgumentException("Unknown coinId: $coinId")
}
}
} | CleanArchJetpackCompose/app/src/androidTest/java/com/example/cleanarchcrypto/util/FakeCoinRepositoryImpl.kt | 3857863265 |
package com.example.cleanarchcrypto
import com.example.cleanarchcrypto.data.remote.dto.CoinDetailDto
import com.example.cleanarchcrypto.data.remote.dto.CoinDto
import com.example.cleanarchcrypto.data.remote.dto.Links
import com.example.cleanarchcrypto.data.remote.dto.Whitepaper
object FakeObjects {
val mockCoinList = listOf<CoinDto>(
CoinDto(
id = "id",
isActive = true,
name = "metc",
rank = 1,
symbol = "ask",
isNew = false,
type = "coin"
)
)
val mockCoinDetail =
CoinDetailDto(
description = "Sample Description",
developmentStatus = "Sample Development Status",
firstDataAt = "2022-01-01",
hardwareWallet = true,
hashAlgorithm = "Sample Hash Algorithm",
id = "sample_id",
isActive = true,
isNew = false,
lastDataAt = "2022-01-31",
links = Links(
explorer = emptyList(),
facebook = emptyList(),
reddit = emptyList(),
sourceCode = emptyList(),
website = emptyList(),
youtube = emptyList()
),
linksExtended = emptyList(),
message = "Sample Message",
name = "Sample Name",
openSource = true,
orgStructure = "Sample Org Structure",
proofType = "Sample Proof Type",
rank = 1,
startedAt = "2022-01-01",
symbol = "SAMPLE",
tags = emptyList(),
team = emptyList(),
type = "Sample Type",
whitepaper = Whitepaper(link = "link", thumbnail = "thumbnail")
)
} | CleanArchJetpackCompose/app/src/androidTest/java/com/example/cleanarchcrypto/FakeObjects.kt | 4111772667 |
package com.example.cleanarchcrypto
import android.app.Application
import android.content.Context
import androidx.test.runner.AndroidJUnitRunner
import dagger.hilt.android.testing.HiltTestApplication
class HiltTestRunner : AndroidJUnitRunner(){
override fun newApplication(
cl: ClassLoader?,
className: String?,
context: Context?
): Application {
return super.newApplication(cl, HiltTestApplication::class.java.name, context)
}
} | CleanArchJetpackCompose/app/src/androidTest/java/com/example/cleanarchcrypto/HiltTestRunner.kt | 143002417 |
package com.example.cleanarchcrypto.presentation.coin_list.components
import androidx.activity.compose.setContent
import androidx.compose.ui.test.assertIsDisplayed
import androidx.compose.ui.test.junit4.createAndroidComposeRule
import androidx.compose.ui.test.onNodeWithTag
import androidx.compose.ui.test.onNodeWithText
import androidx.compose.ui.test.performClick
import androidx.lifecycle.SavedStateHandle
import androidx.navigation.NavHostController
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.rememberNavController
import androidx.test.espresso.matcher.ViewMatchers.assertThat
import com.example.cleanarchcrypto.FakeObjects
import com.example.cleanarchcrypto.di.AppModule
import com.example.cleanarchcrypto.domain.use_case.get_coin.GetCoinUseCase
import com.example.cleanarchcrypto.domain.use_case.get_coins.GetCoinsUseCase
import com.example.cleanarchcrypto.presentation.MainActivity
import com.example.cleanarchcrypto.presentation.Screen
import com.example.cleanarchcrypto.presentation.coin_detail.CoinDetailViewModel
import com.example.cleanarchcrypto.presentation.coin_detail.components.CoinDetailScreen
import com.example.cleanarchcrypto.presentation.coin_list.CoinListViewModel
import com.example.cleanarchcrypto.presentation.theme.CleanArchCryptoTheme
import com.example.cleanarchcrypto.util.FakeCoinRepository
import dagger.hilt.android.testing.HiltAndroidRule
import dagger.hilt.android.testing.HiltAndroidTest
import dagger.hilt.android.testing.UninstallModules
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Rule
import org.junit.Test
@UninstallModules(AppModule::class)
@HiltAndroidTest
class CoinListScreenKtTest {
@get:Rule(order = 0)
val hiltRule = HiltAndroidRule(this)
@get:Rule(order = 1)
val composeRule = createAndroidComposeRule<MainActivity>()
private lateinit var navController: NavHostController
private lateinit var fakeCoinRepository: FakeCoinRepository
private lateinit var getCoinsUseCase: GetCoinsUseCase
private lateinit var getCoinUseCase: GetCoinUseCase
private lateinit var viewModel: CoinListViewModel
private lateinit var detailViewModel: CoinDetailViewModel
@Before
fun setUp() {
hiltRule.inject()
fakeCoinRepository = FakeCoinRepository()
val savedStateHandle = SavedStateHandle(mapOf("coinId" to "btc"))
fakeCoinRepository = FakeCoinRepository()
getCoinUseCase = GetCoinUseCase(fakeCoinRepository)
detailViewModel = CoinDetailViewModel(getCoinUseCase, savedStateHandle)
getCoinsUseCase = GetCoinsUseCase(fakeCoinRepository)
viewModel = CoinListViewModel(getCoinsUseCase = getCoinsUseCase)
composeRule.activity.setContent {
navController = rememberNavController()
CleanArchCryptoTheme {
NavHost(
navController = navController,
startDestination = Screen.CoinListScreen.route
) {
composable(route = Screen.CoinListScreen.route) {
CoinListScreen(navController, viewModel = viewModel)
}
composable(route = Screen.CoinDetailScreen.route + "/{coinId}") {
CoinDetailScreen(detailViewModel)
}
}
}
}
}
@Test
fun coin_list_is_visible() {
composeRule.onNodeWithTag("lazy").assertExists()
composeRule.onNodeWithText("${FakeObjects.mockCoinList[0].rank}. metc (${FakeObjects.mockCoinList[0].symbol})").assertIsDisplayed()
}
@Test
fun click_and_show_coin_detail() {
composeRule.onNodeWithText("${FakeObjects.mockCoinList[0].rank}. metc (${FakeObjects.mockCoinList[0].symbol})").assertIsDisplayed()
composeRule
.onNodeWithText("${FakeObjects.mockCoinList[0].rank}. metc (${FakeObjects.mockCoinList[0].symbol})")
.performClick()
println("route now ${navController
.currentDestination
?.route}")
navController
.currentDestination
?.route
?.startsWith(Screen.CoinDetailScreen.route)?.let { assertTrue(it) }
composeRule.onNodeWithTag("lazydetail").assertIsDisplayed()
composeRule
.onNodeWithTag("coin_detail_title")
.assertIsDisplayed()
}
} | CleanArchJetpackCompose/app/src/androidTest/java/com/example/cleanarchcrypto/presentation/coin_list/components/CoinListScreenKtTest.kt | 1025226964 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.