content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package com.fitness.data.model.network.edamam.params
data class IngredientSearchParams(
val ingredient: String,
val health: String? = null,
val calories: String? = null,
val category: String? = null,
)
| body-balance/data/api/src/main/kotlin/com/fitness/data/model/network/edamam/params/IngredientSearchParams.kt | 1100497140 |
package com.fitness.data.model.network.edamam.params
data class RecipeSearchParams(
val type: String = "any",
val query: String,
val ingredients: String? = null,
val diet: List<String>? = null,
val health: List<String>? = null,
val cuisineType: List<String>? = null,
val mealType: List<String>? = null,
val dishType: List<String>? = null,
val calories: String? = null,
val time: String? = null,
val imageSize: List<String>? = null,
val glycemicIndex: String? = null,
val excluded: List<String>? = null,
val random: String? = null,
val co2EmissionsClass: String? = null,
val tag: List<String>? = null,
val language: String? = null
)
| body-balance/data/api/src/main/kotlin/com/fitness/data/model/network/edamam/params/RecipeSearchParams.kt | 2651792799 |
package com.fitness.data.model.network.edamam.food
import com.squareup.moshi.Json
import com.squareup.moshi.JsonClass
@JsonClass(generateAdapter = true)
data class NutrientsDto(
@Json(name = "CHOCDF") val chocdf: Double? = null,
@Json(name = "ENERC_KCAL") val enerckcal: Double? = null,
@Json(name = "FAT") val fat: Double? = null,
@Json(name = "FIBTG") val fibtg: Double? = null,
@Json(name = "PROCNT") val procnt: Double? = null
) | body-balance/data/api/src/main/kotlin/com/fitness/data/model/network/edamam/food/NutrientsDto.kt | 2138801015 |
package com.fitness.data.model.network.edamam.food
import com.squareup.moshi.JsonClass
@JsonClass(generateAdapter = true)
data class NextDto(
val href: String? = null,
val title: String? = null
) | body-balance/data/api/src/main/kotlin/com/fitness/data/model/network/edamam/food/NextDto.kt | 3355200957 |
package com.fitness.data.model.network.edamam.food
import com.squareup.moshi.JsonClass
@JsonClass(generateAdapter = true)
data class QualifiedDto(
val qualifiers: List<QualifierDto?>? = null,
val weight: Double? = null
) | body-balance/data/api/src/main/kotlin/com/fitness/data/model/network/edamam/food/QualifiedDto.kt | 3450449499 |
package com.fitness.data.model.network.edamam.food
import com.squareup.moshi.JsonClass
@JsonClass(generateAdapter = true)
data class MeasureDto(
val label: String? = null,
val qualified: List<QualifiedDto?>? = null,
val uri: String? = null,
val weight: Double? = null
) | body-balance/data/api/src/main/kotlin/com/fitness/data/model/network/edamam/food/MeasureDto.kt | 697039707 |
package com.fitness.data.model.network.edamam.food
import com.squareup.moshi.JsonClass
@JsonClass(generateAdapter = true)
data class QualifierDto(
val label: String? = null,
val uri: String? = null
) | body-balance/data/api/src/main/kotlin/com/fitness/data/model/network/edamam/food/QualifierDto.kt | 1417359403 |
package com.fitness.data.model.network.edamam.food
import com.squareup.moshi.JsonClass
@JsonClass(generateAdapter = true)
data class FoodDto(
val category: String? = null,
val categoryLabel: String? = null,
val foodId: String? = null,
val image: String? = null,
val knownAs: String? = null,
val label: String? = null,
val nutrients: NutrientsDto? = null
) | body-balance/data/api/src/main/kotlin/com/fitness/data/model/network/edamam/food/FoodDto.kt | 2071094163 |
package com.fitness.data.model.network.edamam.food
import com.squareup.moshi.JsonClass
@JsonClass(generateAdapter = true)
data class FoodDataDto(
val food: FoodDto? = null,
val measures: List<MeasureDto?>? = null
)
| body-balance/data/api/src/main/kotlin/com/fitness/data/model/network/edamam/food/FoodDataDto.kt | 744351580 |
package com.fitness.domain.di
import com.fitness.data.repository.user.UserRepository
import com.fitness.domain.usecase.metrics.CreateUserBodyMetricsFromUserInfoUseCaseImpl
import com.fitness.domain.usecase.metrics.CreateUserBodyMetricsFromUserInfoUseCase
import com.fitness.domain.usecase.metrics.CreateUserRecommendedMacrosUseCase
import com.fitness.domain.usecase.metrics.CreateUserRecommendedMacrosUseCaseImpl
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class MetricsDomainModule {
@Provides
@Singleton
fun provideCreateUserBodyMetricsFromBasicInfoUseCase(userRepository: UserRepository): CreateUserBodyMetricsFromUserInfoUseCase =
CreateUserBodyMetricsFromUserInfoUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideCreateUserBodyMetricsFromUserInfoUseCase(userRepository: UserRepository): CreateUserRecommendedMacrosUseCase =
CreateUserRecommendedMacrosUseCaseImpl(userRepository)
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/di/MetricsDomainModule.kt | 1921612120 |
package com.fitness.domain.di
import com.fitness.data.repository.user.UserRepository
import com.fitness.domain.usecase.user.CreateBasicUserInfoUseCase
import com.fitness.domain.usecase.user.CreateBasicUserInfoUseCaseImpl
import com.fitness.domain.usecase.user.CreateUserBasicFitnessUseCase
import com.fitness.domain.usecase.user.CreateUserBasicFitnessUseCaseImpl
import com.fitness.domain.usecase.user.CreateUserBasicGoalsInfoUseCase
import com.fitness.domain.usecase.user.CreateUserBasicGoalsInfoUseCaseImpl
import com.fitness.domain.usecase.user.CreateUserBasicNutritionInfoUseCase
import com.fitness.domain.usecase.user.CreateUserBasicNutritionInfoUseCaseImpl
import com.fitness.domain.usecase.user.CreateUserUseCase
import com.fitness.domain.usecase.user.CreateUserUseCaseImpl
import com.fitness.domain.usecase.user.DeleteBasicUserInfoUseCase
import com.fitness.domain.usecase.user.DeleteBasicUserInfoUseCaseImpl
import com.fitness.domain.usecase.user.DeleteUserBasicFitnessUseCase
import com.fitness.domain.usecase.user.DeleteUserBasicFitnessUseCaseImpl
import com.fitness.domain.usecase.user.DeleteUserBasicGoalsInfoUseCase
import com.fitness.domain.usecase.user.DeleteUserBasicGoalsInfoUseCaseImpl
import com.fitness.domain.usecase.user.DeleteUserBasicNutritionInfoUseCase
import com.fitness.domain.usecase.user.DeleteUserBasicNutritionInfoUseCaseImpl
import com.fitness.domain.usecase.user.DeleteUserUseCase
import com.fitness.domain.usecase.user.DeleteUserUseCaseImpl
import com.fitness.domain.usecase.user.GetBasicUserInfoUseCase
import com.fitness.domain.usecase.user.GetBasicUserInfoUseCaseImpl
import com.fitness.domain.usecase.user.GetCurrentUserIdUseCase
import com.fitness.domain.usecase.user.GetCurrentUserIdUseCaseImpl
import com.fitness.domain.usecase.user.GetCurrentUserUseCase
import com.fitness.domain.usecase.user.GetCurrentUserUseCaseImpl
import com.fitness.domain.usecase.user.GetUserBasicFitnessUseCase
import com.fitness.domain.usecase.user.GetUserBasicFitnessUseCaseImpl
import com.fitness.domain.usecase.user.GetUserBasicGoalsInfoUseCase
import com.fitness.domain.usecase.user.GetUserBasicGoalsInfoUseCaseImpl
import com.fitness.domain.usecase.user.GetUserBasicNutritionInfoUseCase
import com.fitness.domain.usecase.user.GetUserBasicNutritionInfoUseCaseImpl
import com.fitness.domain.usecase.user.UpdateBasicFitnessInfoUseCase
import com.fitness.domain.usecase.user.UpdateBasicFitnessInfoUseCaseImpl
import com.fitness.domain.usecase.user.UpdateBasicGoalsInfoUseCase
import com.fitness.domain.usecase.user.UpdateBasicGoalsInfoUseCaseImpl
import com.fitness.domain.usecase.user.UpdateBasicNutritionInfoUseCase
import com.fitness.domain.usecase.user.UpdateBasicNutritionInfoUseCaseImpl
import com.fitness.domain.usecase.user.UpdateBasicUserInfoUseCase
import com.fitness.domain.usecase.user.UpdateBasicUserInfoUseCaseImpl
import com.fitness.domain.usecase.user.UpdateUserPreferencesUseCase
import com.fitness.domain.usecase.user.UpdateUserPreferencesUseCaseImpl
import com.fitness.domain.usecase.user.UpdateUserUseCase
import com.fitness.domain.usecase.user.UpdateUserUseCaseImpl
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class UserDomainModule {
@Provides
@Singleton
fun provideCreateBasicUserInfoUseCase(userRepository: UserRepository): CreateBasicUserInfoUseCase =
CreateBasicUserInfoUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideCreateUserBasicFitnessUseCase(userRepository: UserRepository): CreateUserBasicFitnessUseCase =
CreateUserBasicFitnessUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideCreateBasicUserGoalUseCase(userRepository: UserRepository): CreateUserBasicGoalsInfoUseCase =
CreateUserBasicGoalsInfoUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideCreateBasicUserNutritionUseCase(userRepository: UserRepository): CreateUserBasicNutritionInfoUseCase =
CreateUserBasicNutritionInfoUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideCreateUserUseCase(userRepository: UserRepository): CreateUserUseCase =
CreateUserUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideDeleteBasicUserInfoUseCase(userRepository: UserRepository): DeleteBasicUserInfoUseCase =
DeleteBasicUserInfoUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideDeleteUserBasicFitnessUseCase(userRepository: UserRepository): DeleteUserBasicFitnessUseCase =
DeleteUserBasicFitnessUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideDeleteBasicUserGoalUseCase(userRepository: UserRepository): DeleteUserBasicGoalsInfoUseCase =
DeleteUserBasicGoalsInfoUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideDeleteBasicUserNutritionUseCase(userRepository: UserRepository): DeleteUserBasicNutritionInfoUseCase =
DeleteUserBasicNutritionInfoUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideDeleteUserUseCase(userRepository: UserRepository): DeleteUserUseCase =
DeleteUserUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideGetBasicUserInfoUseCase(userRepository: UserRepository): GetBasicUserInfoUseCase =
GetBasicUserInfoUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideGetCurrentUserIdUseCase(userRepository: UserRepository): GetCurrentUserIdUseCase =
GetCurrentUserIdUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideGetCurrentUserUseCase(userRepository: UserRepository): GetCurrentUserUseCase =
GetCurrentUserUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideGetUserBasicFitnessUseCase(userRepository: UserRepository): GetUserBasicFitnessUseCase =
GetUserBasicFitnessUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideGetBasicUserGoalUseCase(userRepository: UserRepository): GetUserBasicGoalsInfoUseCase =
GetUserBasicGoalsInfoUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideGetBasicUserNutritionUseCase(userRepository: UserRepository): GetUserBasicNutritionInfoUseCase =
GetUserBasicNutritionInfoUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideUpdateBasicUserInfoUseCase(userRepository: UserRepository): UpdateBasicUserInfoUseCase =
UpdateBasicUserInfoUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideUpdateUserBasicFitnessUseCase(userRepository: UserRepository): UpdateBasicFitnessInfoUseCase =
UpdateBasicFitnessInfoUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideUpdateBasicUserGoalUseCase(userRepository: UserRepository): UpdateBasicGoalsInfoUseCase =
UpdateBasicGoalsInfoUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideUpdateBasicUserNutritionUseCase(userRepository: UserRepository): UpdateBasicNutritionInfoUseCase =
UpdateBasicNutritionInfoUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideUpdateUserUseCase(userRepository: UserRepository): UpdateUserUseCase =
UpdateUserUseCaseImpl(userRepository)
@Provides
@Singleton
fun provideUpdateUserPreferencesUseCase(userRepository: UserRepository): UpdateUserPreferencesUseCase =
UpdateUserPreferencesUseCaseImpl(userRepository)
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/di/UserDomainModule.kt | 886139020 |
package com.fitness.domain.di
import com.fitness.data.repository.edamam.EdamamAutoCompleteRepository
import com.fitness.data.repository.edamam.EdamamFoodRepository
import com.fitness.data.repository.edamam.EdamamRecipeRepository
import com.fitness.domain.usecase.search.EdamamAutoCompleteUseCase
import com.fitness.domain.usecase.search.EdamamAutoCompleteUseCaseImpl
import com.fitness.domain.usecase.search.EdamamFetchAllIngredientsUseCase
import com.fitness.domain.usecase.search.EdamamFetchAllIngredientsUseCaseImpl
import com.fitness.domain.usecase.search.EdamamFetchRecipesUseCaseImpl
import com.fitness.domain.usecase.search.EdamamIngredientSearchUseCase
import com.fitness.domain.usecase.search.EdamamIngredientSearchUseCaseImpl
import com.fitness.domain.usecase.search.EdamamRecipeSearchUseCase
import com.fitness.domain.usecase.search.EdamamRecipeSearchUseCaseImpl
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import util.RecipeFetchUseCase
import util.RecipeSearchUseCase
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class EdamamDomainModule {
@Provides
@Singleton
fun provideEdamamAutoCompleteUseCase(repository: EdamamAutoCompleteRepository): EdamamAutoCompleteUseCase =
EdamamAutoCompleteUseCaseImpl(repository)
@Provides
@Singleton
@RecipeSearchUseCase
fun provideEdamamRecipeSearchUseCase(repository: EdamamRecipeRepository): EdamamRecipeSearchUseCase =
EdamamRecipeSearchUseCaseImpl(repository)
@Provides
@Singleton
@RecipeFetchUseCase
fun provideEdamamFetchRecipesUseCase(repository: EdamamRecipeRepository): EdamamRecipeSearchUseCase =
EdamamFetchRecipesUseCaseImpl(repository)
@Provides
@Singleton
fun provideEdamamFoodSearchUseCase(repository: EdamamFoodRepository): EdamamIngredientSearchUseCase =
EdamamIngredientSearchUseCaseImpl(repository)
@Provides
@Singleton
fun provideEdamamFetchAllIngredientsUseCaseImpl(repository: EdamamFoodRepository): EdamamFetchAllIngredientsUseCase = EdamamFetchAllIngredientsUseCaseImpl(repository)
}
| body-balance/domain/impl/src/main/kotlin/com/fitness/domain/di/EdamamDomainModule.kt | 2443559755 |
package com.fitness.domain.di
import com.fitness.data.repository.nutrition.NutritionRecordRepository
import com.fitness.domain.usecase.nutrition.CreateNutritionRecordUseCase
import com.fitness.domain.usecase.nutrition.CreateNutritionRecordUseCaseImpl
import com.fitness.domain.usecase.nutrition.GetEditableNutritionRecordsUseCase
import com.fitness.domain.usecase.nutrition.GetEditableNutritionRecordsUseCaseImpl
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import javax.inject.Inject
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class NutritionDomainModule {
@Provides
@Singleton
fun provideCreateNutritionRecordUseCaseUseCase(repository: NutritionRecordRepository): CreateNutritionRecordUseCase = CreateNutritionRecordUseCaseImpl(repository)
@Provides
@Singleton
fun provideGetEditableNutritionRecordsUseCase(repository: NutritionRecordRepository): GetEditableNutritionRecordsUseCase = GetEditableNutritionRecordsUseCaseImpl(repository)
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/di/NutritionDomainModule.kt | 1669432489 |
package com.fitness.domain.di
import com.fitness.data.repository.auth.AuthRepository
import com.fitness.domain.usecase.auth.EmailPasswordSignInUseCase
import com.fitness.domain.usecase.auth.EmailPasswordSignInUseCaseImpl
import com.fitness.domain.usecase.auth.EmailPasswordSignUpUseCase
import com.fitness.domain.usecase.auth.EmailPasswordSignUpUseCaseImpl
import com.fitness.domain.usecase.auth.SendPasswordResetEmailUseCase
import com.fitness.domain.usecase.auth.SendPasswordResetEmailUseCaseImpl
import com.fitness.domain.usecase.auth.SendVerificationCodeUseCase
import com.fitness.domain.usecase.auth.SendVerificationCodeUseCaseImpl
import com.fitness.domain.usecase.auth.SignOutUseCase
import com.fitness.domain.usecase.auth.SignOutUseCaseImpl
import com.fitness.domain.usecase.auth.VerifyPhoneNumberUseCase
import com.fitness.domain.usecase.auth.VerifyPhoneNumberUseCaseImpl
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class AuthDomainModule {
@Provides
@Singleton
fun provideEmailPasswordSignInUseCase(authRepository: AuthRepository): EmailPasswordSignInUseCase =
EmailPasswordSignInUseCaseImpl(authRepository)
@Provides
@Singleton
fun provideEmailPasswordSignUpUseCase(authRepository: AuthRepository): EmailPasswordSignUpUseCase =
EmailPasswordSignUpUseCaseImpl(authRepository)
@Provides
@Singleton
fun provideSendPasswordResetEmailUseCase(authRepository: AuthRepository): SendPasswordResetEmailUseCase =
SendPasswordResetEmailUseCaseImpl(authRepository)
@Provides
@Singleton
fun provideSendVerificationCodeUseCase(authRepository: AuthRepository): SendVerificationCodeUseCase =
SendVerificationCodeUseCaseImpl(authRepository)
@Provides
@Singleton
fun provideSignOutUseCase(authRepository: AuthRepository): SignOutUseCase =
SignOutUseCaseImpl(authRepository)
@Provides
@Singleton
fun provideVerifyPhoneNumberUseCase(authRepository: AuthRepository): VerifyPhoneNumberUseCase =
VerifyPhoneNumberUseCaseImpl(authRepository)
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/di/AuthDomainModule.kt | 291961912 |
package com.fitness.domain.usecase.metrics
import com.fitness.analytics.calculateCarbs
import com.fitness.analytics.calculateFat
import com.fitness.analytics.calculateFiber
import com.fitness.analytics.calculateProtein
import com.fitness.analytics.calculateTDEE
import com.fitness.data.repository.user.UserRepository
import com.fitness.domain.model.metrics.UserRecommendedMacros
import com.fitness.domain.model.toUserRecommendedMacrosCache
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class CreateUserRecommendedMacrosUseCaseImpl @Inject constructor(private val repository: UserRepository) : CreateUserRecommendedMacrosUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val metrics = params.bodyMetrics
val level = params.level
val tdee = calculateTDEE(metrics.basalMetabolicRate, level)
val protein = calculateProtein(tdee)
val fat = calculateFat(tdee)
val carbs = calculateCarbs(tdee)
val fiber = calculateFiber(tdee)
val macros = UserRecommendedMacros(
userId = metrics.userId,
calories = tdee,
totalDailyEnergyExpenditure = tdee,
carbohydrates = carbs,
fat = fat,
protein = protein,
fiber = fiber
).toUserRecommendedMacrosCache()
emit(repository.updateUserRecommendedMetrics(metrics.userId, macros))
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/metrics/CreateUserRecommendedMacrosUseCaseImpl.kt | 3370509192 |
package com.fitness.domain.usecase.metrics
import com.fitness.analytics.calculateBMR
import com.fitness.data.repository.user.UserRepository
import com.fitness.domain.model.metrics.UserBodyMetrics
import com.fitness.domain.model.toUserBodyMetricsCache
import enums.ELengthUnit
import enums.EMassUnit
import enums.SystemOfMeasurement
import enums.convertLength
import enums.convertMass
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class CreateUserBodyMetricsFromUserInfoUseCaseImpl @Inject constructor(private val repository: UserRepository) : CreateUserBodyMetricsFromUserInfoUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val basicInfo = params.info
val unitSystem = params.unitSystem
val massUnit = if(unitSystem == SystemOfMeasurement.METRIC) EMassUnit.KILOGRAM else EMassUnit.POUNDS
val lengthUnit = if(unitSystem == SystemOfMeasurement.METRIC) ELengthUnit.CENTIMETER else ELengthUnit.INCHES
val height = basicInfo.height
val weight = basicInfo.weight
val waist = basicInfo.waist
val age = basicInfo.age
val gender = basicInfo.gender
val bmi = weight.div(height.times(height))
val basal = calculateBMR(
gender = gender,
weightKg = convertMass(weight, massUnit, EMassUnit.KILOGRAM),
heightCm = convertLength(height, lengthUnit, ELengthUnit.CENTIMETER),
waistCm = convertLength(waist, lengthUnit, ELengthUnit.CENTIMETER),
ageYears = age,
)
val bodyMetrics = UserBodyMetrics(userId = basicInfo.userId, bodyMassIndex = bmi, bodyFatPercentage = 0.0, basalMetabolicRate = basal)
when(val result = repository.updateUserBodyMetrics(id = basicInfo.userId, metrics = bodyMetrics.toUserBodyMetricsCache())){
is DataState.Success -> emit(result)
is DataState.Error -> emit(result)
}
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/metrics/CreateUserBodyMetricsFromUserInfoUseCaseImpl.kt | 2332761231 |
package com.fitness.domain.usecase.auth
import auth.authenticate
import com.fitness.data.repository.auth.AuthRepository
import com.fitness.domain.model.toUserDomain
import com.fitness.domain.model.user.User
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class EmailPasswordSignInUseCaseImpl @Inject constructor(private val repository: AuthRepository) : EmailPasswordSignInUseCase() {
override suspend fun FlowCollector<DataState<User>>.execute(params: Params) {
val result = repository.signInWithEmail(params.email, params.password)
val user = authenticate { result }.map { it.toUserDomain() }
emit(user)
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/auth/EmailPasswordSignInUseCaseImpl.kt | 2622729092 |
package com.fitness.domain.usecase.auth
import cache.firestore
import com.fitness.data.repository.auth.AuthRepository
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class SendPasswordResetEmailUseCaseImpl @Inject constructor(
private val repository: AuthRepository
) : SendPasswordResetEmailUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val authResult = repository.sendPasswordResetEmail(params.email)
val result = firestore { authResult }
emit(result)
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/auth/SendPasswordResetEmailUseCaseImpl.kt | 2541893575 |
package com.fitness.domain.usecase.auth
import auth.authenticate
import com.fitness.data.repository.auth.AuthRepository
import com.fitness.domain.model.toUserDomain
import com.fitness.domain.model.user.User
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class EmailPasswordSignUpUseCaseImpl @Inject constructor(private val authRepository: AuthRepository) : EmailPasswordSignUpUseCase() {
override suspend fun FlowCollector<DataState<User>>.execute(params: Params) {
val result = authRepository.signUpWithEmail(
firstname = params.firstname,
lastname = params.lastname,
email = params.email,
password = params.password
)
val user = authenticate { result }.map { it.toUserDomain() }
emit(user)
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/auth/EmailPasswordSignUpUseCaseImpl.kt | 3775137851 |
package com.fitness.domain.usecase.auth
import auth.PhoneAuthState
import com.fitness.data.repository.auth.AuthRepository
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class SendVerificationCodeUseCaseImpl @Inject constructor(private val repository: AuthRepository) : SendVerificationCodeUseCase() {
override suspend fun FlowCollector<DataState<PhoneAuthState>>.execute(params: Params) {
repository.sendVerificationCode(params.phoneNumber).collect {
when(it){
is PhoneAuthState.Error -> throw it.exception
else -> { emit(DataState.Success(it)) }
}
}
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/auth/SendVerificationCodeUseCaseImpl.kt | 3160142996 |
package com.fitness.domain.usecase.auth
import com.fitness.data.repository.auth.AuthRepository
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class SignOutUseCaseImpl @Inject constructor(private val authRepository: AuthRepository) : SignOutUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
emit(DataState.Success(authRepository.signOut()))
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/auth/SignOutUseCaseImpl.kt | 3323705859 |
package com.fitness.domain.usecase.auth
import auth.phoneAuthenticate
import com.fitness.data.repository.auth.AuthRepository
import com.fitness.domain.model.toUserDomain
import com.fitness.domain.model.user.User
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class VerifyPhoneNumberUseCaseImpl @Inject constructor(private val repository: AuthRepository) : VerifyPhoneNumberUseCase() {
override suspend fun FlowCollector<DataState<User>>.execute(params: Params) {
val result = repository.verifyPhoneNumberWithCode(params.verificationId, params.code)
val user = phoneAuthenticate(params.verificationId) { result }.map { it.toUserDomain() }
emit(user)
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/auth/VerifyPhoneNumberUseCaseImpl.kt | 4259378604 |
package com.fitness.domain.usecase.user
import cache.cast
import cache.firestore
import com.fitness.data.model.cache.user.UserBasicInfoCache
import com.fitness.data.repository.user.UserRepository
import com.fitness.domain.model.toUserBasicInfo
import com.fitness.domain.model.user.UserBasicInfo
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class GetBasicUserInfoUseCaseImpl @Inject constructor(
private val userRepository: UserRepository
) : GetBasicUserInfoUseCase() {
override suspend fun FlowCollector<DataState<UserBasicInfo>>.execute(params: Params) {
when(val firestoreResult = userRepository.readUserBasicInfo(params.id)){
is DataState.Success -> {
val castedResult = cast<UserBasicInfoCache> { firestoreResult.result }
val result = firestore { castedResult }.map{ it.toUserBasicInfo() }
emit(result)
}
is DataState.Error -> {
emit(firestoreResult)
}
}
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/GetBasicUserInfoUseCaseImpl.kt | 3126073397 |
package com.fitness.domain.usecase.user
import com.fitness.data.repository.user.UserRepository
import failure.AuthStateFailure
import kotlinx.coroutines.flow.FlowCollector
import kotlinx.coroutines.tasks.await
import state.DataState
import javax.inject.Inject
class GetCurrentUserIdUseCaseImpl @Inject constructor(
private val userRepository: UserRepository
) : GetCurrentUserIdUseCase() {
override suspend fun FlowCollector<DataState<String>>.execute(params: Params) {
val currentUserId = userRepository.getCurrentUserId().await()
if(currentUserId != null) {
emit(DataState.Success(currentUserId))
}
else {
emit(DataState.Error(AuthStateFailure()))
}
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/GetCurrentUserIdUseCaseImpl.kt | 2106340875 |
package com.fitness.domain.usecase.user
import cache.cast
import cache.firestore
import com.fitness.data.model.cache.user.UserBasicFitnessLevelCache
import com.fitness.data.repository.user.UserRepository
import com.fitness.domain.model.toUserFitnessLevel
import com.fitness.domain.model.user.UserFitnessLevel
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class GetUserBasicFitnessUseCaseImpl @Inject constructor(
private val userRepository: UserRepository
) : GetUserBasicFitnessUseCase() {
override suspend fun FlowCollector<DataState<UserFitnessLevel>>.execute(params: Params) {
when(val firestoreResult = userRepository.readBasicFitnessInfo(params.id)){
is DataState.Success -> {
val castedResult = cast<UserBasicFitnessLevelCache> { firestoreResult.result }
val result = firestore { castedResult }.map{ it.toUserFitnessLevel() }
emit(result)
}
is DataState.Error -> {
emit(firestoreResult)
}
}
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/GetUserBasicFitnessUseCaseImpl.kt | 2508785052 |
package com.fitness.domain.usecase.user
import com.fitness.data.repository.user.UserRepository
import com.fitness.domain.model.toUserCache
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class CreateUserUseCaseImpl @Inject constructor(private val userRepository: UserRepository) : CreateUserUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
params.userDomain.isTermAndPrivacyAccepted = true
val result = userRepository.createUser(params.userDomain.toUserCache())
emit(result)
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/CreateUserUseCaseImpl.kt | 298329789 |
package com.fitness.domain.usecase.user
import com.fitness.data.repository.user.UserRepository
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class DeleteUserBasicFitnessUseCaseImpl @Inject constructor(
private val userRepository: UserRepository
) : DeleteUserBasicFitnessUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val result = userRepository.deleteBasicFitnessInfo(params.id)
emit(result)
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/DeleteUserBasicFitnessUseCaseImpl.kt | 372720643 |
package com.fitness.domain.usecase.user
import cache.Fields
import com.fitness.data.repository.user.UserRepository
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class UpdateBasicNutritionInfoUseCaseImpl @Inject constructor(
private val userRepository: UserRepository
) : UpdateBasicNutritionInfoUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val result = when(params){
is Params.UpdateRestrictions -> {
userRepository.updateBasicNutritionInfo(params.id, mapOf(Fields.RESTRICTIONS to params.restrictions, Fields.LAST_UPDATED to System.currentTimeMillis()))
}
is Params.UpdatePreferences -> {
userRepository.updateBasicNutritionInfo(params.id, mapOf(Fields.PREFERENCES to params.preferences, Fields.LAST_UPDATED to System.currentTimeMillis()))
}
}
emit(result)
}
}
| body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/UpdateBasicNutritionInfoUseCaseImpl.kt | 2446544361 |
package com.fitness.domain.usecase.user
import cache.Fields
import com.fitness.data.repository.user.UserRepository
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class UpdateBasicUserInfoUseCaseImpl @Inject constructor(
private val userRepository: UserRepository
) : UpdateBasicUserInfoUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val result = when(params){
is Params.UpdateAge -> {
userRepository.updateUserBasicInfo(params.id, mapOf(Fields.AGE to params.age, Fields.LAST_UPDATED to System.currentTimeMillis()))
}
is Params.UpdateGender -> {
userRepository.updateUserBasicInfo(params.id, mapOf(Fields.GENDER to params.gender, Fields.LAST_UPDATED to System.currentTimeMillis()))
}
is Params.UpdateHeight -> {
userRepository.updateUserBasicInfo(params.id, mapOf(Fields.HEIGHT to params.height, Fields.LAST_UPDATED to System.currentTimeMillis()))
}
is Params.UpdateWeight -> {
userRepository.updateUserBasicInfo(params.id, mapOf(Fields.WEIGHT to params.weight, Fields.LAST_UPDATED to System.currentTimeMillis()))
}
}
emit(result)
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/UpdateBasicUserInfoUseCaseImpl.kt | 921873823 |
package com.fitness.domain.usecase.user
import com.fitness.data.repository.user.UserRepository
import com.fitness.domain.model.toUserBasicInfoCache
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class CreateBasicUserInfoUseCaseImpl @Inject constructor(private val userRepository: UserRepository) : CreateBasicUserInfoUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val result = userRepository.createUserBasicInfo(info = params.userBasicInfoDomain.toUserBasicInfoCache())
emit(result)
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/CreateBasicUserInfoUseCaseImpl.kt | 3444873211 |
package com.fitness.domain.usecase.user
import cache.Fields
import com.fitness.data.repository.user.UserRepository
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class UpdateBasicFitnessInfoUseCaseImpl @Inject constructor(
private val userRepository: UserRepository
) : UpdateBasicFitnessInfoUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val result = when(params){
is Params.UpdateRestrictions -> {
userRepository.updateBasicFitnessInfo(params.id, mapOf(Fields.LEVEL to params.level, Fields.LAST_UPDATED to System.currentTimeMillis()))
}
is Params.UpdatePreferences -> {
userRepository.updateBasicFitnessInfo(params.id, mapOf(Fields.HABITS to params.habits, Fields.LAST_UPDATED to System.currentTimeMillis()))
}
}
emit(result)
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/UpdateBasicFitnessInfoUseCaseImpl.kt | 1699545060 |
package com.fitness.domain.usecase.user
import cache.Fields
import com.fitness.data.repository.user.UserRepository
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class UpdateBasicGoalsInfoUseCaseImpl @Inject constructor(
private val userRepository: UserRepository
) : UpdateBasicGoalsInfoUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val result = userRepository.updateUserBasicGoalsInfo(params.id, mapOf(Fields.GOALS to params.goals, Fields.LAST_UPDATED to System.currentTimeMillis()))
emit(result)
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/UpdateBasicGoalsInfoUseCaseImpl.kt | 2616508415 |
package com.fitness.domain.usecase.user
import com.fitness.data.repository.user.UserRepository
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class DeleteUserBasicNutritionInfoUseCaseImpl @Inject constructor(
private val userRepository: UserRepository
) : DeleteUserBasicNutritionInfoUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val result = userRepository.deleteBasicNutritionInfo(params.id)
emit(result)
}
}
| body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/DeleteUserBasicNutritionInfoUseCaseImpl.kt | 2968768417 |
package com.fitness.domain.usecase.user
import com.fitness.data.repository.user.UserRepository
import com.fitness.domain.model.toUserBasicGoalsInfoCache
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class CreateUserBasicGoalsInfoUseCaseImpl @Inject constructor(private val userRepository: UserRepository) :
CreateUserBasicGoalsInfoUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val result = userRepository.createUserBasicGoalsInfo(info = params.userBasicGoalsInfo.toUserBasicGoalsInfoCache())
emit(result)
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/CreateUserBasicGoalsInfoUseCaseImpl.kt | 3972895200 |
package com.fitness.domain.usecase.user
import com.fitness.data.repository.user.UserRepository
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class DeleteBasicUserInfoUseCaseImpl @Inject constructor(
private val userRepository: UserRepository
) : DeleteBasicUserInfoUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val result = userRepository.deleteUserBasicInfo(params.id)
emit(result)
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/DeleteBasicUserInfoUseCaseImpl.kt | 518363458 |
package com.fitness.domain.usecase.user
import com.fitness.data.repository.user.UserRepository
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class DeleteUserBasicGoalsInfoUseCaseImpl @Inject constructor(
private val userRepository: UserRepository
) : DeleteUserBasicGoalsInfoUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val result = userRepository.deleteUserBasicGoalsInfo(params.id)
emit(result)
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/DeleteUserBasicGoalsInfoUseCaseImpl.kt | 988247606 |
package com.fitness.domain.usecase.user
import com.fitness.data.repository.user.UserRepository
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class DeleteUserUseCaseImpl @Inject constructor(
private val userRepository: UserRepository
) : DeleteUserUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val result = userRepository.deleteUser(params.id)
emit(result)
}
}
| body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/DeleteUserUseCaseImpl.kt | 4261202251 |
package com.fitness.domain.usecase.user
import cache.cast
import cache.firestore
import com.fitness.data.model.cache.user.UserBasicNutritionInfoCache
import com.fitness.data.repository.user.UserRepository
import com.fitness.domain.model.toUserBasicNutritionInfo
import com.fitness.domain.model.user.UserBasicNutritionInfo
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class GetUserBasicNutritionInfoUseCaseImpl @Inject constructor(
private val userRepository: UserRepository
) : GetUserBasicNutritionInfoUseCase() {
override suspend fun FlowCollector<DataState<UserBasicNutritionInfo>>.execute(params: Params) {
when(val firestoreResult = userRepository.readBasicNutritionInfo(params.id)){
is DataState.Success -> {
val castedResult = cast<UserBasicNutritionInfoCache> { firestoreResult.result }
val result = firestore { castedResult }.map{ it.toUserBasicNutritionInfo() }
emit(result)
}
is DataState.Error -> {
emit(firestoreResult)
}
}
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/GetUserBasicNutritionInfoUseCaseImpl.kt | 3365431859 |
package com.fitness.domain.usecase.user
import com.fitness.data.repository.user.UserRepository
import com.fitness.domain.model.toUserFitnessLevelCache
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class CreateUserBasicFitnessUseCaseImpl @Inject constructor(private val userRepository: UserRepository) :
CreateUserBasicFitnessUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val result = userRepository.createBasicFitnessInfo(info = params.userBasicInfoDomain.toUserFitnessLevelCache())
emit(result)
}
}
| body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/CreateUserBasicFitnessUseCaseImpl.kt | 1040781298 |
package com.fitness.domain.usecase.user
import com.fitness.data.repository.user.UserRepository
import com.fitness.domain.model.toUserPreferencesCache
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class UpdateUserPreferencesUseCaseImpl@Inject constructor(private val userRepository: UserRepository): UpdateUserPreferencesUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
emit(userRepository.updateUserPreferences(params.id, params.userPreferences.toUserPreferencesCache()))
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/UpdateUserPreferencesUseCaseImpl.kt | 2996572894 |
package com.fitness.domain.usecase.user
import com.fitness.data.repository.user.UserRepository
import com.fitness.domain.model.toUserBasicNutritionInfoCache
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class CreateUserBasicNutritionInfoUseCaseImpl @Inject constructor(private val userRepository: UserRepository) :
CreateUserBasicNutritionInfoUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val result = userRepository.createBasicNutritionInfo(info = params.userBasicNutritionInfo.toUserBasicNutritionInfoCache())
emit(result)
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/CreateUserBasicNutritionInfoUseCaseImpl.kt | 2099307401 |
package com.fitness.domain.usecase.user
import cache.Fields
import com.fitness.data.repository.user.UserRepository
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class UpdateUserUseCaseImpl @Inject constructor(
private val userRepository: UserRepository
) : UpdateUserUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val result = when(params){
is Params.UpdateEmail -> {
userRepository.updateUser(params.id, mapOf(Fields.EMAIL to params.email, Fields.LAST_UPDATED to System.currentTimeMillis()))
}
is Params.UpdateDisplayName -> {
userRepository.updateUser(params.id, mapOf(Fields.DISPLAY_NAME to "${params.firstname} ${params.lastname}", Fields.LAST_UPDATED to System.currentTimeMillis()))
}
is Params.UpdatePhoneNumber -> {
userRepository.updateUser(params.id, mapOf(Fields.PHONE_NUMBER to params.phone, Fields.LAST_UPDATED to System.currentTimeMillis()))
}
is Params.UpdateProfilePictureUrl -> {
userRepository.updateUser(params.id, mapOf(Fields.PROFILE_PICTURE_URL to params.profilePictureUrl, Fields.LAST_UPDATED to System.currentTimeMillis()))
}
is Params.UpdateIsTermsPrivacyAccepted -> {
userRepository.updateUser(params.id, mapOf(Fields.IS_TERMS_PRIVACY_ACCEPTED to params.isTermAndPrivacyAccepted, Fields.LAST_UPDATED to System.currentTimeMillis()))
}
is Params.UpdateIsNewUser -> {
userRepository.updateUser(params.id, mapOf(Fields.IS_NEW_USER to params.isNewUser, Fields.LAST_UPDATED to System.currentTimeMillis()))
}
}
emit(result)
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/UpdateUserUseCaseImpl.kt | 548356756 |
package com.fitness.domain.usecase.user
import cache.cast
import cache.firestore
import com.fitness.data.model.cache.user.UserCache
import com.fitness.data.repository.user.UserRepository
import com.fitness.domain.model.toUser
import com.fitness.domain.model.user.User
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class GetCurrentUserUseCaseImpl @Inject constructor(
private val userRepository: UserRepository
) : GetCurrentUserUseCase() {
override suspend fun FlowCollector<DataState<User>>.execute(params: Params) {
when(val firestoreResult = userRepository.readUser(params.id)){
is DataState.Success -> {
val castedResult = cast<UserCache> { firestoreResult.result }
val result = firestore { castedResult }.map{ it.toUser() }
emit(result)
}
is DataState.Error -> {
emit(firestoreResult)
}
}
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/GetCurrentUserUseCaseImpl.kt | 2935860198 |
package com.fitness.domain.usecase.user
import cache.cast
import cache.firestore
import com.fitness.data.model.cache.user.UserBasicGoalsInfoCache
import com.fitness.data.repository.user.UserRepository
import com.fitness.domain.model.toUserBasicGoalsInfo
import com.fitness.domain.model.user.UserBasicGoalsInfo
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class GetUserBasicGoalsInfoUseCaseImpl @Inject constructor(
private val userRepository: UserRepository
) : GetUserBasicGoalsInfoUseCase() {
override suspend fun FlowCollector<DataState<UserBasicGoalsInfo>>.execute(params: Params) {
when(val firestoreResult = userRepository.readUserBasicGoalsInfo(params.id)){
is DataState.Success -> {
val castedResult = cast<UserBasicGoalsInfoCache> { firestoreResult.result }
val result = firestore { castedResult }.map{ it.toUserBasicGoalsInfo() }
emit(result)
}
is DataState.Error -> {
emit(firestoreResult)
}
}
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/user/GetUserBasicGoalsInfoUseCaseImpl.kt | 664643646 |
package com.fitness.domain.usecase.search
import com.fitness.data.repository.edamam.EdamamFoodRepository
import com.fitness.domain.model.nutrition.Ingredient
import com.fitness.domain.model.nutrition.toIngredient
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class EdamamFetchAllIngredientsUseCaseImpl @Inject constructor(private val repository: EdamamFoodRepository): EdamamFetchAllIngredientsUseCase(){
override suspend fun FlowCollector<DataState<List<Ingredient>>>.execute(params: Params) {
val results = repository.getAllFood().map { it.toIngredient() }
emit(DataState.Success(results))
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/search/EdamamFetchAllIngredientsUseCaseImpl.kt | 2672137204 |
package com.fitness.domain.usecase.search
import com.fitness.data.repository.edamam.EdamamRecipeRepository
import com.fitness.domain.model.nutrition.Recipe
import com.fitness.domain.model.nutrition.toRecipeFromRecipeDto
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class EdamamRecipeSearchUseCaseImpl @Inject constructor(
private val repository: EdamamRecipeRepository
) : EdamamRecipeSearchUseCase() {
override suspend fun FlowCollector<DataState<List<Recipe>>>.execute(params: Params) {
val results = repository.search(params.toSearchQuery()).map { it.toRecipeFromRecipeDto() }
emit(DataState.Success(results))
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/search/EdamamRecipeSearchUseCaseImpl.kt | 43258592 |
package com.fitness.domain.usecase.search
import com.fitness.data.model.network.edamam.params.IngredientBrandParams
import com.fitness.data.model.network.edamam.params.IngredientSearchParams
import com.fitness.data.repository.edamam.EdamamFoodRepository
import com.fitness.domain.model.nutrition.Ingredient
import com.fitness.domain.model.nutrition.toIngredient
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class EdamamIngredientSearchUseCaseImpl @Inject constructor(private val repository: EdamamFoodRepository) :
EdamamIngredientSearchUseCase() {
override suspend fun FlowCollector<DataState<List<Ingredient>>>.execute(params: Params) {
params.search?.let { query ->
val searchParams = IngredientSearchParams(
ingredient = query,
health = params.health,
calories = params.calories,
category = params.category
)
val food = repository.getFoodByIngredient(searchParams).map { it.toIngredient() }
emit(DataState.Success(food))
} ?: params.brand?.let { brand ->
val searchParams = IngredientBrandParams(
brand = brand,
health = params.health,
calories = params.calories,
category = params.category
)
val food = repository.getFoodByBrand(searchParams).map { it.toIngredient() }
emit(DataState.Success(food))
} ?: throw Exception()
}
}
| body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/search/EdamamIngredientSearchUseCaseImpl.kt | 1822593448 |
package com.fitness.domain.usecase.search
import com.fitness.data.repository.edamam.EdamamRecipeRepository
import com.fitness.domain.model.nutrition.Recipe
import com.fitness.domain.model.nutrition.toRecipeFromRecipeDto
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class EdamamFetchRecipesUseCaseImpl @Inject constructor(
private val repository: EdamamRecipeRepository
) : EdamamRecipeSearchUseCase() {
override suspend fun FlowCollector<DataState<List<Recipe>>>.execute(params: Params) {
val result = repository.fetchRecipes(params.toSearchQuery()).map { it.toRecipeFromRecipeDto() }
emit(DataState.Success(result))
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/search/EdamamFetchRecipesUseCaseImpl.kt | 3567993521 |
package com.fitness.domain.usecase.search
import com.fitness.data.repository.edamam.EdamamAutoCompleteRepository
import kotlinx.coroutines.flow.FlowCollector
import kotlinx.coroutines.tasks.await
import javax.inject.Inject
class EdamamAutoCompleteUseCaseImpl @Inject constructor(private val repository: EdamamAutoCompleteRepository): EdamamAutoCompleteUseCase() {
override suspend fun FlowCollector<List<String>>.execute(params: Params) {
val result = repository.autoComplete(q = params.search).await()
emit(result)
}
}
| body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/search/EdamamAutoCompleteUseCaseImpl.kt | 3005360190 |
package com.fitness.domain.usecase.nutrition
import cache.generateUniqueId
import com.fitness.data.repository.nutrition.NutritionRecordRepository
import com.fitness.domain.model.nutrition.Nutrition
import com.fitness.domain.model.nutrition.toNutritionEntity
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import util.convertToDateTimeString
import javax.inject.Inject
class CreateNutritionRecordUseCaseImpl @Inject constructor(private val repository: NutritionRecordRepository): CreateNutritionRecordUseCase() {
override suspend fun FlowCollector<DataState<Unit>>.execute(params: Params) {
val nutrition = Nutrition(
recordId = generateUniqueId("${params.recipe.recipeId}-${params.userId}"),
userId = params.userId,
recipe = params.recipe,
dateTime = convertToDateTimeString(params.date, params.hour, params.minute),
mealType = params.mealType
)
emit(repository.createNutritionRecord(nutrition.toNutritionEntity()))
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/nutrition/CreateNutritionRecordUseCaseImpl.kt | 3656366413 |
package com.fitness.domain.usecase.nutrition
import com.fitness.data.repository.nutrition.NutritionRecordRepository
import com.fitness.domain.model.nutrition.Nutrition
import com.fitness.domain.model.nutrition.toNutrition
import kotlinx.coroutines.flow.FlowCollector
import state.DataState
import javax.inject.Inject
class GetEditableNutritionRecordsUseCaseImpl @Inject constructor(private val repository: NutritionRecordRepository): GetEditableNutritionRecordsUseCase() {
override suspend fun FlowCollector<DataState<List<Nutrition>>>.execute(params: Params) {
when(val dataState = repository.getEditableNutritionRecord(params.userId)){
is DataState.Success -> {
emit(DataState.Success(dataState.result.map { it.toNutrition() }))
}
is DataState.Error -> emit(dataState)
}
}
} | body-balance/domain/impl/src/main/kotlin/com/fitness/domain/usecase/nutrition/GetEditableNutritionRecordsUseCaseImpl.kt | 3321490192 |
package com.fitness.domain.model.metrics
data class UserRecommendedMacros (
val userId: String,
val fat: Double,
val protein: Double,
val calories: Double,
val totalDailyEnergyExpenditure: Double,
val carbohydrates: Double,
val fiber: Double
) | body-balance/domain/api/src/main/kotlin/com/fitness/domain/model/metrics/UserRecommendedMacros.kt | 1368490216 |
package com.fitness.domain.model.metrics
data class UserBodyMetrics (
val userId: String,
val bodyMassIndex: Double,
val bodyFatPercentage: Double,
val basalMetabolicRate: Double
)
| body-balance/domain/api/src/main/kotlin/com/fitness/domain/model/metrics/UserBodyMetrics.kt | 674353402 |
package com.fitness.domain.model
import com.fitness.data.extensions.toApiParamFromECuisineType
import com.fitness.data.extensions.toApiParamFromEHealthLabel
import com.fitness.data.extensions.toCuisineType
import com.fitness.data.extensions.toDietaryRestrictions
import com.fitness.data.extensions.toEnumName
import com.fitness.data.extensions.toHealthLabel
import com.fitness.data.model.cache.metrics.UserBodyMetricsCache
import com.fitness.data.model.cache.metrics.UserRecommendedMacrosCache
import com.fitness.data.model.cache.user.UserBasicFitnessLevelCache
import com.fitness.data.model.cache.user.UserBasicGoalsInfoCache
import com.fitness.data.model.cache.user.UserBasicInfoCache
import com.fitness.data.model.cache.user.UserBasicNutritionInfoCache
import com.fitness.data.model.cache.user.UserCache
import com.fitness.data.model.cache.user.UserPreferencesCache
import com.fitness.domain.model.metrics.UserBodyMetrics
import com.fitness.domain.model.metrics.UserRecommendedMacros
import com.google.firebase.auth.FirebaseUser
import com.fitness.domain.model.user.UserBasicGoalsInfo
import com.fitness.domain.model.user.UserBasicInfo
import com.fitness.domain.model.user.UserBasicNutritionInfo
import com.fitness.domain.model.user.User
import com.fitness.domain.model.user.UserFitnessLevel
import com.fitness.domain.model.user.UserPreferences
// Extension function to convert FirebaseUser to UserDomain
fun FirebaseUser.toUserDomain(): User {
return User(
id = this.uid,
displayName = this.displayName,
email = this.email,
phoneNumber = this.phoneNumber,
isTermAndPrivacyAccepted = false,
profilePictureUrl = this.photoUrl?.toString(),
isNewUser = false,
userPreferences = UserPreferences()
)
}
// Extension function to convert UserCache to User
fun UserCache.toUser(): User {
return User(
id = this.id,
displayName = this.displayName,
email = this.email,
phoneNumber = this.phoneNumber,
isTermAndPrivacyAccepted = this.isTermAndPrivacyAccepted,
profilePictureUrl = this.profilePictureUrl,
isNewUser = isNewUser,
userPreferences = userPreferences?.toUserPreferences() ?: UserPreferences()
)
}
// Extension function to convert User to UserCache
fun User.toUserCache(lastUpdated: Long = System.currentTimeMillis()): UserCache {
return UserCache(
id = this.id,
displayName = this.displayName,
email = this.email,
phoneNumber = this.phoneNumber,
profilePictureUrl = this.profilePictureUrl,
isTermAndPrivacyAccepted = this.isTermAndPrivacyAccepted,
lastUpdated = lastUpdated,
isNewUser = isNewUser ?: false,
userPreferences = userPreferences.toUserPreferencesCache()
)
}
fun UserPreferences.toUserPreferencesCache(): UserPreferencesCache =
UserPreferencesCache(
systemOfMeasurement = this.systemOfMeasurement
)
fun UserPreferencesCache.toUserPreferences(): UserPreferences =
UserPreferences(
systemOfMeasurement = this.systemOfMeasurement
)
// Extension function to convert UserBasicInfo to UserBasicInfoCache
fun UserBasicInfo.toUserBasicInfoCache(lastUpdated: Long = System.currentTimeMillis()): UserBasicInfoCache {
return UserBasicInfoCache(
userId = this.userId,
age = this.age,
gender = this.gender,
height = this.height,
weight = this.weight,
waist = this.waist,
lastUpdated = lastUpdated
)
}
// Extension function to convert UserBasicInfoCache to UserBasicInfo
fun UserBasicInfoCache.toUserBasicInfo(): UserBasicInfo {
return UserBasicInfo(
userId = this.userId,
age = this.age,
gender = this.gender,
height = this.height,
weight = this.weight,
waist = this.waist,
)
}
fun UserBasicFitnessLevelCache.toUserFitnessLevel(): UserFitnessLevel {
return UserFitnessLevel(
userId = this.userId,
level = this.level,
habits = this.habits
)
}
fun UserFitnessLevel.toUserFitnessLevelCache(lastUpdated: Long = System.currentTimeMillis()): UserBasicFitnessLevelCache {
return UserBasicFitnessLevelCache(
userId = this.userId,
level = this.level,
habits = this.habits,
lastUpdated = lastUpdated
)
}
fun UserBasicNutritionInfo.toUserBasicNutritionInfoCache(lastUpdated: Long = System.currentTimeMillis()): UserBasicNutritionInfoCache {
return UserBasicNutritionInfoCache(
userId = userId,
restrictions = restrictions.toEnumName(),
healthLabels = healthLabels.toEnumName(),
healthLabelsApi = healthLabels.toApiParamFromEHealthLabel(),
cuisineType = cuisineType.toEnumName(),
cuisineTypeApi = cuisineType.toApiParamFromECuisineType(),
lastUpdated = lastUpdated
)
}
fun UserBasicNutritionInfoCache.toUserBasicNutritionInfo(): UserBasicNutritionInfo {
return UserBasicNutritionInfo(
userId = userId,
restrictions = restrictions.toDietaryRestrictions(),
healthLabels = healthLabels.toHealthLabel(),
cuisineType = cuisineType.toCuisineType(),
healthLabelsApi = healthLabelsApi,
cuisineTypeApi = cuisineTypeApi,
)
}
fun UserBasicGoalsInfo.toUserBasicGoalsInfoCache(lastUpdated: Long = System.currentTimeMillis()): UserBasicGoalsInfoCache {
return UserBasicGoalsInfoCache(
userId = userId,
goals = goals,
lastUpdated = lastUpdated
)
}
fun UserBasicGoalsInfoCache.toUserBasicGoalsInfo(): UserBasicGoalsInfo {
return UserBasicGoalsInfo(
userId = userId,
goals = goals
)
}
fun UserBodyMetricsCache.toUserBodyMetrics(): UserBodyMetrics {
return UserBodyMetrics(
userId = userId,
bodyMassIndex = bodyMassIndex,
bodyFatPercentage = bodyFatPercentage,
basalMetabolicRate = basalMetabolicRate
)
}
fun UserBodyMetrics.toUserBodyMetricsCache(): UserBodyMetricsCache {
return UserBodyMetricsCache(
userId = userId,
bodyMassIndex = bodyMassIndex,
bodyFatPercentage = bodyFatPercentage,
basalMetabolicRate = basalMetabolicRate
)
}
fun UserRecommendedMacrosCache.toUserRecommendedMacros(): UserRecommendedMacros {
return UserRecommendedMacros(
userId = userId,
fat = fat,
protein = protein,
calories = calories,
totalDailyEnergyExpenditure = totalDailyEnergyExpenditure,
carbohydrates = carbohydrates,
fiber = fiber,
)
}
fun UserRecommendedMacros.toUserRecommendedMacrosCache(): UserRecommendedMacrosCache {
return UserRecommendedMacrosCache(
userId = userId,
fat = fat,
protein = protein,
calories = calories,
totalDailyEnergyExpenditure = totalDailyEnergyExpenditure,
carbohydrates = carbohydrates,
fiber = fiber,
)
}
| body-balance/domain/api/src/main/kotlin/com/fitness/domain/model/UserExtensions.kt | 2537139623 |
package com.fitness.domain.model.user
import com.fitness.data.extensions.toApiParamFromECuisineType
import com.fitness.data.extensions.toApiParamFromEHealthLabel
import enums.ECuisineType
import enums.EDietaryRestrictions
import enums.EHealthLabel
data class UserBasicNutritionInfo(
val userId: String,
val restrictions: List<EDietaryRestrictions>,
val healthLabels: List<EHealthLabel>,
val healthLabelsApi: List<String> = healthLabels.toApiParamFromEHealthLabel(),
val cuisineType: List<ECuisineType>,
val cuisineTypeApi: List<String> = cuisineType.toApiParamFromECuisineType(),
)
| body-balance/domain/api/src/main/kotlin/com/fitness/domain/model/user/UserBasicNutritionInfo.kt | 2893336568 |
package com.fitness.domain.model.user
import enums.EGender
import enums.ELengthUnit
import enums.EMassUnit
import enums.SystemOfMeasurement
data class UserBasicInfo(
val userId: String,
val age: Int,
val gender: EGender,
val height: Double,
val weight: Double,
val waist: Double
) | body-balance/domain/api/src/main/kotlin/com/fitness/domain/model/user/UserBasicInfo.kt | 856966567 |
package com.fitness.domain.model.user
import enums.EFitnessInterest
import enums.EPhysicalActivityLevel
data class UserFitnessLevel(
val userId: String,
val level: EPhysicalActivityLevel,
val habits: List<EFitnessInterest>
) | body-balance/domain/api/src/main/kotlin/com/fitness/domain/model/user/UserFitnessLevel.kt | 3861219258 |
package com.fitness.domain.model.user
data class User(
val id: String,
var displayName: String?,
var email: String?,
var phoneNumber: String?,
var isTermAndPrivacyAccepted: Boolean,
var profilePictureUrl: String?,
var isNewUser: Boolean?,
val userPreferences: UserPreferences
)
| body-balance/domain/api/src/main/kotlin/com/fitness/domain/model/user/User.kt | 687848607 |
package com.fitness.domain.model.user
import enums.EGoals
data class UserBasicGoalsInfo(
val userId: String,
val goals: List<EGoals>,
)
| body-balance/domain/api/src/main/kotlin/com/fitness/domain/model/user/UserBasicGoalsInfo.kt | 1584002872 |
package com.fitness.domain.model.user
import enums.SystemOfMeasurement
data class UserPreferences(
val systemOfMeasurement: SystemOfMeasurement = SystemOfMeasurement.METRIC
) | body-balance/domain/api/src/main/kotlin/com/fitness/domain/model/user/UserPreferences.kt | 1508324819 |
package com.fitness.domain.model.nutrition
import cache.generateUniqueId
import enums.EMealType
import java.time.OffsetDateTime
import java.time.format.DateTimeFormatter
import java.time.format.DateTimeParseException
data class Nutrition(
val userId: String = "",
val dateTime: String = "",
val mealType: EMealType = EMealType.BREAKFAST,
val recipe: Recipe = Recipe(),
val recordId: String = generateUniqueId("$userId-$dateTime-${recipe.recipeId}"),
)
fun Nutrition.getDateAsLong(): Long {
return try {
val offsetDateTime = OffsetDateTime.parse(dateTime, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss XXX"))
offsetDateTime.toInstant().toEpochMilli()
} catch (e: DateTimeParseException) {
0L
}
}
fun Nutrition.getTimeFromDate(): Pair<Int, Int> {
return try {
val offsetDateTime = OffsetDateTime.parse(dateTime, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss XXX"))
val time = offsetDateTime.toLocalTime()
Pair(time.hour, time.minute)
} catch (e: DateTimeParseException) {
Pair(0, 0)
}
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/model/nutrition/Nutrition.kt | 2511674852 |
package com.fitness.domain.model.nutrition
import cache.generateUniqueId
data class Recipe(
val calories: Double? = null,
val large: String? = null,
val regular: String? = null,
val small: String? = null,
val thumbnail: String? = null,
val name: String? = null,
val mealType: List<String>? = null,
val shareAs: String? = null,
val source: String? = null,
val tags: List<String>? = null,
val totalTime: Double? = null,
val totalWeight: Double? = null,
val recipeUri: String? = null,
val recipeUrl: String? = null,
val yield: Double? = null,
val cautions: List<String>? = null,
val cuisineType: List<String>? = null,
val dietLabels: List<String>? = null,
val dishType: List<String>? = null,
val healthLabels: List<String>? = null,
val standardImage: String? = null,
val ingredientLines: List<String>? = null,
val instructions: List<String>? = null,
val ingredients: List<Ingredient>? = null,
val nutrients: Map<String, Nutrient>? = null,
val recipeId: String = generateRecipeId("$recipeUri-$recipeUrl", ingredients)
)
fun generateRecipeId(input: String, ingredients: List<Ingredient>?): String {
var foodId = ""
ingredients?.forEach {
foodId += it.foodId
}
return generateUniqueId("$input-$foodId")
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/model/nutrition/Recipe.kt | 2768833151 |
package com.fitness.domain.model.nutrition
data class Nutrient(
val label: String,
val quantity: Double,
val unit: String
) | body-balance/domain/api/src/main/kotlin/com/fitness/domain/model/nutrition/Nutrients.kt | 1762689211 |
package com.fitness.domain.model.nutrition
data class Qualifier(
val label: String? = null,
val uri: String? = null
) | body-balance/domain/api/src/main/kotlin/com/fitness/domain/model/nutrition/Qualifier.kt | 987906924 |
package com.fitness.domain.model.nutrition
data class Measure(
val label: String? = null,
val qualified: List<Qualified>? = null,
val uri: String? = null,
val weight: Double? = null
) | body-balance/domain/api/src/main/kotlin/com/fitness/domain/model/nutrition/Measure.kt | 663081059 |
package com.fitness.domain.model.nutrition
import com.fitness.data.model.cache.nutrition.IngredientEntity
import com.fitness.data.model.cache.nutrition.MeasureEntity
import com.fitness.data.model.cache.nutrition.NutrientEntity
import com.fitness.data.model.cache.nutrition.NutritionEntity
import com.fitness.data.model.cache.nutrition.QualifiedEntity
import com.fitness.data.model.cache.nutrition.QualifierEntity
import com.fitness.data.model.cache.nutrition.RecipeEntity
import com.fitness.data.model.network.edamam.recipe.IngredientDto
import com.fitness.data.model.network.edamam.recipe.RecipeDto
import com.fitness.data.model.network.edamam.shared.TotalNutrientsDto
import com.fitness.data.util.TotalNutrientsKeys
fun Nutrition.toNutritionEntity(): NutritionEntity =
NutritionEntity(
recordId = recordId,
userId = userId,
dateTime = dateTime,
mealType = mealType,
recipe = recipe.toRecipeEntity()
)
fun NutritionEntity.toNutrition(): Nutrition =
Nutrition(
recordId = recordId,
userId = userId,
dateTime = dateTime,
mealType = mealType,
recipe = recipe.toRecipe()
)
fun Recipe.toRecipeEntity(): RecipeEntity =
RecipeEntity(
recipeId = recipeId,
calories = calories,
cautions = cautions,
cuisineType = cuisineType,
dietLabels = dietLabels,
dishType = dishType,
healthLabels = healthLabels,
standardImage = standardImage,
large = large,
regular = regular,
small = small,
thumbnail = thumbnail,
ingredientLines = ingredientLines,
instructionLines = instructions,
label = name,
mealType = mealType,
shareAs = shareAs,
source = source,
tags = tags,
totalTime = totalTime,
totalWeight = totalWeight,
recipeUri = recipeUri,
recipeUrl = recipeUrl,
yield = yield,
ingredients = ingredients?.map { it.toIngredientEntity() },
nutrients = nutrients.toNutrientEntityMap()
)
fun RecipeEntity.toRecipe(): Recipe =
Recipe(
recipeId = recipeId,
calories = calories,
cautions = cautions,
cuisineType = cuisineType,
dietLabels = dietLabels,
dishType = dishType,
healthLabels = healthLabels,
standardImage = standardImage,
large = large,
regular = regular,
small = small,
thumbnail = thumbnail,
ingredientLines = ingredientLines,
instructions = instructionLines,
name = label,
mealType = mealType,
shareAs = shareAs,
source = source,
tags = tags,
totalTime = totalTime,
totalWeight = totalWeight,
recipeUri = recipeUri,
recipeUrl = recipeUrl,
yield = yield,
ingredients = ingredients?.map { it.toIngredient() },
nutrients = nutrients.toNutrientsMap()
)
fun RecipeDto.toRecipeFromRecipeDto(): Recipe = Recipe(
calories = calories,
cautions = cautions,
cuisineType = cuisineType,
dietLabels = dietLabels,
dishType = dishType,
healthLabels = healthLabels,
standardImage = image,
large = images?.large?.url,
regular = images?.regular?.url,
small = images?.small?.url,
thumbnail = images?.thumbnail?.url,
ingredientLines = ingredientLines,
name = label,
mealType = mealType,
shareAs = shareAs,
source = source,
tags = tags,
totalTime = totalTime,
totalWeight = totalWeight,
recipeUri = uri,
recipeUrl = url,
yield = yield,
ingredients = ingredients?.map { it.toIngredientFromIngredientDto() },
nutrients = totalNutrients?.toNutrientFromTotalNutrientsDto()
)
fun Ingredient.toIngredientEntity(): IngredientEntity =
IngredientEntity(
name = name,
foodId = foodId,
image = image,
quantity = quantity,
detailed = detailed,
weight = weight,
uri = uri,
category = category,
categoryName = categoryName,
cautions = cautions,
dietLabels = dietLabels,
healthLabels = healthLabels,
totalWeight = totalWeight,
qualifiedUri = qualifiedUri,
qualifiedName = qualifiedName,
qualifiedWeight = qualifiedWeight,
measureUri = measureUri,
measureName = measureName,
measureWeight = measureWeight,
measures = measures?.map { it.toMeasureEntity() },
nutrients = nutrients.toNutrientEntityMap()
)
fun IngredientEntity.toIngredient(): Ingredient =
Ingredient(
name = name,
foodId = foodId,
image = image,
quantity = quantity,
detailed = detailed,
weight = weight,
uri = uri,
category = category,
categoryName = categoryName,
cautions = cautions,
dietLabels = dietLabels,
healthLabels = healthLabels,
totalWeight = totalWeight,
qualifiedUri = qualifiedUri,
qualifiedName = qualifiedName,
qualifiedWeight = qualifiedWeight,
measureUri = measureUri,
measureName = measureName,
measureWeight = measureWeight,
measures = measures?.map { it.toMeasure() },
nutrients = nutrients.toNutrientsMap()
)
fun IngredientDto.toIngredientFromIngredientDto(): Ingredient =
Ingredient(
foodId = foodId,
name = food,
category = foodCategory,
image = image,
measureName = measure,
quantity = quantity,
detailed = text,
weight = weight,
)
fun Map<String, Nutrient>?.toNutrientEntityMap(): Map<String, NutrientEntity>? {
return this?.mapValues { it.value.toNutrientEntity() }
}
fun Map<String, NutrientEntity>?.toNutrientsMap(): Map<String, Nutrient>? {
return this?.mapValues { it.value.toNutrient() }
}
fun Nutrient.toNutrientEntity(): NutrientEntity =
NutrientEntity(
label = label,
quantity = quantity,
unit = unit
)
fun NutrientEntity.toNutrient(): Nutrient =
Nutrient(
label = label,
quantity = quantity,
unit = unit
)
fun TotalNutrientsDto.toNutrientFromTotalNutrientsDto(): Map<String, Nutrient> = mapOf(
TotalNutrientsKeys.KEY_CALCIUM to Nutrient(
ca?.label ?: "",
ca?.quantity ?: 0.0,
ca?.unit ?: ""
),
TotalNutrientsKeys.KEY_CARBOHYDRATES to Nutrient(
chocdf?.label ?: "",
chocdf?.quantity ?: 0.0,
chocdf?.unit ?: ""
),
TotalNutrientsKeys.KEY_NET_CARBS to Nutrient(
chocdfnet?.label ?: "",
chocdfnet?.quantity ?: 0.0,
chocdfnet?.unit ?: ""
),
TotalNutrientsKeys.KEY_CHOLESTEROL to Nutrient(
chole?.label ?: "",
chole?.quantity ?: 0.0,
chole?.unit ?: ""
),
TotalNutrientsKeys.KEY_ENERGY to Nutrient(
enerckcal?.label ?: "",
enerckcal?.quantity ?: 0.0,
enerckcal?.unit ?: ""
),
TotalNutrientsKeys.KEY_MONOUNSATURATED_FATS to Nutrient(
fams?.label ?: "",
fams?.quantity ?: 0.0,
fams?.unit ?: ""
),
TotalNutrientsKeys.KEY_POLYUNSATURATED_FATS to Nutrient(
fapu?.label ?: "",
fapu?.quantity ?: 0.0,
fapu?.unit ?: ""
),
TotalNutrientsKeys.KEY_SATURATED_FATS to Nutrient(
fasat?.label ?: "",
fasat?.quantity ?: 0.0,
fasat?.unit ?: ""
),
TotalNutrientsKeys.KEY_TOTAL_FAT to Nutrient(
fat?.label ?: "",
fat?.quantity ?: 0.0,
fat?.unit ?: ""
),
TotalNutrientsKeys.KEY_TRANS_FAT to Nutrient(
fatrn?.label ?: "",
fatrn?.quantity ?: 0.0,
fatrn?.unit ?: ""
),
TotalNutrientsKeys.KEY_IRON to Nutrient(fe?.label ?: "", fe?.quantity ?: 0.0, fe?.unit ?: ""),
TotalNutrientsKeys.KEY_FIBER to Nutrient(
fibtg?.label ?: "",
fibtg?.quantity ?: 0.0,
fibtg?.unit ?: ""
),
TotalNutrientsKeys.KEY_FOLIC_ACID to Nutrient(
folac?.label ?: "",
folac?.quantity ?: 0.0,
folac?.unit ?: ""
),
TotalNutrientsKeys.KEY_FOLATE_DFE to Nutrient(
foldfe?.label ?: "",
foldfe?.quantity ?: 0.0,
foldfe?.unit ?: ""
),
TotalNutrientsKeys.KEY_FOOD_FOLATE to Nutrient(
folfd?.label ?: "",
folfd?.quantity ?: 0.0,
folfd?.unit ?: ""
),
TotalNutrientsKeys.KEY_POTASSIUM to Nutrient(k?.label ?: "", k?.quantity ?: 0.0, k?.unit ?: ""),
TotalNutrientsKeys.KEY_MAGNESIUM to Nutrient(
mg?.label ?: "",
mg?.quantity ?: 0.0,
mg?.unit ?: ""
),
TotalNutrientsKeys.KEY_SODIUM to Nutrient(na?.label ?: "", na?.quantity ?: 0.0, na?.unit ?: ""),
TotalNutrientsKeys.KEY_NIACIN to Nutrient(
nia?.label ?: "",
nia?.quantity ?: 0.0,
nia?.unit ?: ""
),
TotalNutrientsKeys.KEY_PHOSPHORUS to Nutrient(
p?.label ?: "",
p?.quantity ?: 0.0,
p?.unit ?: ""
),
TotalNutrientsKeys.KEY_PROTEIN to Nutrient(
procnt?.label ?: "",
procnt?.quantity ?: 0.0,
procnt?.unit ?: ""
),
TotalNutrientsKeys.KEY_RIBOFLAVIN to Nutrient(
ribf?.label ?: "",
ribf?.quantity ?: 0.0,
ribf?.unit ?: ""
),
TotalNutrientsKeys.KEY_SUGARS to Nutrient(
sugar?.label ?: "",
sugar?.quantity ?: 0.0,
sugar?.unit ?: ""
),
TotalNutrientsKeys.KEY_ADDED_SUGARS to Nutrient(
sugaradded?.label ?: "",
sugaradded?.quantity ?: 0.0,
sugaradded?.unit ?: ""
),
TotalNutrientsKeys.KEY_THIAMIN to Nutrient(
thia?.label ?: "",
thia?.quantity ?: 0.0,
thia?.unit ?: ""
),
TotalNutrientsKeys.KEY_VITAMIN_E to Nutrient(
tocpaha?.label ?: "",
tocpaha?.quantity ?: 0.0,
tocpaha?.unit ?: ""
),
TotalNutrientsKeys.KEY_VITAMIN_A to Nutrient(
vitarAE?.label ?: "",
vitarAE?.quantity ?: 0.0,
vitarAE?.unit ?: ""
),
TotalNutrientsKeys.KEY_VITAMIN_B12 to Nutrient(
vitb12?.label ?: "",
vitb12?.quantity ?: 0.0,
vitb12?.unit ?: ""
),
TotalNutrientsKeys.KEY_VITAMIN_B6 to Nutrient(
vitb6a?.label ?: "",
vitb6a?.quantity ?: 0.0,
vitb6a?.unit ?: ""
),
TotalNutrientsKeys.KEY_VITAMIN_C to Nutrient(
vitc?.label ?: "",
vitc?.quantity ?: 0.0,
vitc?.unit ?: ""
),
TotalNutrientsKeys.KEY_VITAMIN_D to Nutrient(
vitd?.label ?: "",
vitd?.quantity ?: 0.0,
vitd?.unit ?: ""
),
TotalNutrientsKeys.KEY_VITAMIN_K1 to Nutrient(
vitk1?.label ?: "",
vitk1?.quantity ?: 0.0,
vitk1?.unit ?: ""
),
TotalNutrientsKeys.KEY_WATER to Nutrient(
water?.label ?: "",
water?.quantity ?: 0.0,
water?.unit ?: ""
),
TotalNutrientsKeys.KEY_ZINC to Nutrient(zn?.label ?: "", zn?.quantity ?: 0.0, zn?.unit ?: "")
)
fun Measure.toMeasureEntity(): MeasureEntity =
MeasureEntity(
label = this.label,
qualified = this.qualified?.map { it.toQualifiedEntity() },
uri = this.uri,
weight = this.weight
)
fun Qualified.toQualifiedEntity(): QualifiedEntity =
QualifiedEntity(
qualifiers = this.qualifiers?.map { it.toQualifierEntity() },
weight = this.weight
)
fun Qualifier.toQualifierEntity(): QualifierEntity {
return QualifierEntity(
label = this.label,
uri = this.uri
)
}
fun MeasureEntity.toMeasure(): Measure =
Measure(
label = this.label,
qualified = this.qualified?.map { it.toQualified() },
uri = this.uri,
weight = this.weight
)
fun QualifiedEntity.toQualified(): Qualified =
Qualified(
qualifiers = this.qualifiers?.map { it.toQualifier() },
weight = this.weight
)
fun QualifierEntity.toQualifier(): Qualifier {
return Qualifier(
label = this.label,
uri = this.uri
)
}
| body-balance/domain/api/src/main/kotlin/com/fitness/domain/model/nutrition/NutritionDomainExtensions.kt | 381990233 |
package com.fitness.domain.model.nutrition
data class Qualified(
val qualifiers: List<Qualifier>? = null,
val weight: Double? = null
) | body-balance/domain/api/src/main/kotlin/com/fitness/domain/model/nutrition/Qualified.kt | 3626853533 |
package com.fitness.domain.model.nutrition
data class Ingredient(
val name: String? = null,
val foodId: String? = null,
val image: String? = null,
val quantity: Double? = null,
val detailed: String? = null,
val weight: Double? = null,
val uri: String? = null,
val category: String? = null,
val categoryName: String? = null,
val cautions: List<String>? = null,
val dietLabels: List<String>? = null,
val healthLabels: List<String>? = null,
val totalWeight: Double? = null,
val qualifiedUri: String? = null, // The qualified uri that corresponds with the name for selected qualifier. Value determined based on what qualified name user chooses.
val qualifiedName: String? = null, // if available represents teh different states the ingredient can be in which affect the final weight. For instance cheese can be sliced, shredded, melted etc
val qualifiedWeight: Double? = null, // The qualified weight for selected qualifier. Value determined based on what qualifier the user chooses.
val measureUri: String? = null, // The measure uri that corresponds with the name (cup, tablespoon, etc) for selected measure. Value determined based on what measure name user chooses.
val measureName: String? = null, // The measure name (cup, tablespoon, etc) for selected measure. Value determined by user.
val measureWeight: Double? = null, // The measure weight for selected measure. Value determined based on what measure name user chooses.
val measures: List<Measure>? = null,
val nutrients: Map<String, Nutrient>? = null
)
| body-balance/domain/api/src/main/kotlin/com/fitness/domain/model/nutrition/Ingredient.kt | 1180631628 |
package com.fitness.domain.usecase.metrics
import com.fitness.domain.model.user.UserBasicInfo
import com.fitness.domain.model.user.UserFitnessLevel
import enums.ELengthUnit
import enums.EMassUnit
import enums.SystemOfMeasurement
import usecase.DataStateUseCase
abstract class CreateUserBodyMetricsFromUserInfoUseCase: DataStateUseCase<CreateUserBodyMetricsFromUserInfoUseCase.Params, Unit>() {
data class Params(val info: UserBasicInfo, val unitSystem: SystemOfMeasurement)
}
| body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/metrics/CreateUserBodyMetricsFromUserInfoUseCase.kt | 148074973 |
package com.fitness.domain.usecase.metrics
import com.fitness.domain.model.metrics.UserBodyMetrics
import enums.EPhysicalActivityLevel
import usecase.DataStateUseCase
abstract class CreateUserRecommendedMacrosUseCase: DataStateUseCase<CreateUserRecommendedMacrosUseCase.Params, Unit>() {
data class Params(val bodyMetrics: UserBodyMetrics, val level: EPhysicalActivityLevel)
}
| body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/metrics/CreateUserRecommendedMacrosUseCase.kt | 1131948934 |
package com.fitness.domain.usecase.auth
import com.fitness.domain.model.user.User
import usecase.DataStateUseCase
abstract class EmailPasswordSignUpUseCase: DataStateUseCase<EmailPasswordSignUpUseCase.Params, User>() {
data class Params(val firstname: String, val lastname: String, val email: String, val password: String)
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/auth/EmailPasswordSignUpUseCase.kt | 3828907828 |
package com.fitness.domain.usecase.auth
import usecase.DataStateUseCase
abstract class SendPasswordResetEmailUseCase : DataStateUseCase<SendPasswordResetEmailUseCase.Params, Unit>() {
data class Params(val email: String)
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/auth/SendPasswordResetEmailUseCase.kt | 2697145251 |
package com.fitness.domain.usecase.auth
import com.fitness.domain.model.user.User
import usecase.DataStateUseCase
abstract class EmailPasswordSignInUseCase : DataStateUseCase<EmailPasswordSignInUseCase.Params, User>() {
data class Params(val email: String, val password: String)
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/auth/EmailPasswordSignInUseCase.kt | 1461622508 |
package com.fitness.domain.usecase.auth
import com.fitness.domain.model.user.User
import usecase.DataStateUseCase
abstract class VerifyPhoneNumberUseCase: DataStateUseCase<VerifyPhoneNumberUseCase.Params, User>() {
data class Params(val verificationId: String, val code: String)
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/auth/VerifyPhoneNumberUseCase.kt | 3441581448 |
package com.fitness.domain.usecase.auth
import usecase.DataStateUseCase
abstract class SignOutUseCase: DataStateUseCase<SignOutUseCase.Params, Unit>() {
object Params
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/auth/SignOutUseCase.kt | 3901609347 |
package com.fitness.domain.usecase.auth
import auth.PhoneAuthState
import usecase.DataStateUseCase
abstract class SendVerificationCodeUseCase : DataStateUseCase<SendVerificationCodeUseCase.Params, PhoneAuthState>() {
data class Params(val phoneNumber: String)
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/auth/SendVerificationCodeUseCase.kt | 3502247948 |
package com.fitness.domain.usecase.user
import usecase.DataStateUseCase
abstract class UpdateUserUseCase: DataStateUseCase<UpdateUserUseCase.Params, Unit>(){
sealed class Params{
data class UpdateDisplayName(val id: String, val firstname: String, val lastname: String): Params()
data class UpdateEmail(val id: String, val email: String): Params()
data class UpdatePhoneNumber(val id: String, val phone: String): Params()
data class UpdateProfilePictureUrl(val id: String, val profilePictureUrl: String): Params()
data class UpdateIsTermsPrivacyAccepted(val id: String, val isTermAndPrivacyAccepted: Boolean): Params()
data class UpdateIsNewUser(val id: String, val isNewUser: Boolean): Params()
}
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/UpdateUserUseCase.kt | 3045344171 |
package com.fitness.domain.usecase.user
import com.fitness.domain.model.user.UserFitnessLevel
import usecase.DataStateUseCase
abstract class CreateUserBasicFitnessUseCase : DataStateUseCase<CreateUserBasicFitnessUseCase.Params, Unit>() {
data class Params(val userBasicInfoDomain: UserFitnessLevel)
}
| body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/CreateUserBasicFitnessUseCase.kt | 1237573833 |
package com.fitness.domain.usecase.user
import usecase.DataStateUseCase
abstract class GetCurrentUserIdUseCase: DataStateUseCase<GetCurrentUserIdUseCase.Params, String>(){
object Params
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/GetCurrentUserIdUseCase.kt | 2931580165 |
package com.fitness.domain.usecase.user
import com.fitness.domain.model.user.UserBasicInfo
import usecase.DataStateUseCase
abstract class GetBasicUserInfoUseCase: DataStateUseCase<GetBasicUserInfoUseCase.Params, UserBasicInfo>(){
data class Params(val id: String)
}
| body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/GetBasicUserInfoUseCase.kt | 1891978102 |
package com.fitness.domain.usecase.user
import enums.EFitnessInterest
import enums.EPhysicalActivityLevel
import usecase.DataStateUseCase
abstract class UpdateBasicFitnessInfoUseCase: DataStateUseCase<UpdateBasicFitnessInfoUseCase.Params, Unit>(){
sealed class Params{
data class UpdateRestrictions(val id: String, val level: EPhysicalActivityLevel): Params()
data class UpdatePreferences(val id: String, val habits: List<EFitnessInterest>): Params()
}
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/UpdateBasicFitnessInfoUseCase.kt | 1657843831 |
package com.fitness.domain.usecase.user
import usecase.DataStateUseCase
abstract class DeleteUserBasicGoalsInfoUseCase: DataStateUseCase<DeleteUserBasicGoalsInfoUseCase.Params, Unit>(){
data class Params(val id: String)
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/DeleteUserBasicGoalsInfoUseCase.kt | 2631364329 |
package com.fitness.domain.usecase.user
import com.fitness.domain.model.user.User
import usecase.DataStateUseCase
abstract class GetCurrentUserUseCase: DataStateUseCase<GetCurrentUserUseCase.Params, User>(){
data class Params(val id: String)
}
| body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/GetCurrentUserUseCase.kt | 1425746585 |
package com.fitness.domain.usecase.user
import com.fitness.domain.model.user.UserBasicNutritionInfo
import usecase.DataStateUseCase
abstract class GetUserBasicNutritionInfoUseCase : DataStateUseCase<GetUserBasicNutritionInfoUseCase.Params, UserBasicNutritionInfo>(){
data class Params(val id: String)
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/GetUserBasicNutritionInfoUseCase.kt | 1691556936 |
package com.fitness.domain.usecase.user
import enums.EDietaryRestrictions
import enums.ENutritionPreferences
import usecase.DataStateUseCase
abstract class UpdateBasicNutritionInfoUseCase: DataStateUseCase<UpdateBasicNutritionInfoUseCase.Params, Unit>(){
sealed class Params{
data class UpdateRestrictions(val id: String, val restrictions: List<EDietaryRestrictions>): Params()
data class UpdatePreferences(val id: String, val preferences: List<ENutritionPreferences>): Params()
}
}
| body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/UpdateBasicNutritionInfoUseCase.kt | 1370952278 |
package com.fitness.domain.usecase.user
import com.fitness.domain.model.user.UserBasicNutritionInfo
import usecase.DataStateUseCase
abstract class CreateUserBasicNutritionInfoUseCase : DataStateUseCase<CreateUserBasicNutritionInfoUseCase.Params, Unit>() {
data class Params(val userBasicNutritionInfo: UserBasicNutritionInfo)
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/CreateUserBasicNutritionInfoUseCase.kt | 3821034338 |
package com.fitness.domain.usecase.user
import enums.EGoals
import usecase.DataStateUseCase
abstract class UpdateBasicGoalsInfoUseCase: DataStateUseCase<UpdateBasicGoalsInfoUseCase.Params, Unit>(){
data class Params(val id: String, val goals: List<EGoals>)
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/UpdateBasicGoalsInfoUseCase.kt | 4000806819 |
package com.fitness.domain.usecase.user
import usecase.DataStateUseCase
abstract class DeleteUserBasicNutritionInfoUseCase: DataStateUseCase<DeleteUserBasicNutritionInfoUseCase.Params, Unit>(){
data class Params(val id: String)
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/DeleteUserBasicNutritionInfoUseCase.kt | 1503434083 |
package com.fitness.domain.usecase.user
import usecase.DataStateUseCase
abstract class DeleteUserBasicFitnessUseCase : DataStateUseCase<DeleteUserBasicFitnessUseCase.Params, Unit>(){
data class Params(val id: String)
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/DeleteUserBasicFitnessUseCase.kt | 3023946510 |
package com.fitness.domain.usecase.user
import enums.EGender
import usecase.DataStateUseCase
abstract class UpdateBasicUserInfoUseCase: DataStateUseCase<UpdateBasicUserInfoUseCase.Params, Unit>(){
sealed class Params{
data class UpdateAge(val id: String, val age: Int): Params()
data class UpdateGender(val id: String, val gender: EGender): Params()
data class UpdateHeight(val id: String, val height: Double): Params()
data class UpdateWeight(val id: String, val weight: Double): Params()
}
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/UpdateBasicUserInfoUseCase.kt | 1728174510 |
package com.fitness.domain.usecase.user
import usecase.DataStateUseCase
abstract class DeleteUserUseCase: DataStateUseCase<DeleteUserUseCase.Params, Unit>(){
data class Params(val id: String)
}
| body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/DeleteUserUseCase.kt | 1715747456 |
package com.fitness.domain.usecase.user
import com.fitness.domain.model.user.UserBasicGoalsInfo
import usecase.DataStateUseCase
abstract class CreateUserBasicGoalsInfoUseCase: DataStateUseCase<CreateUserBasicGoalsInfoUseCase.Params, Unit>(){
data class Params(val userBasicGoalsInfo: UserBasicGoalsInfo)
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/CreateUserBasicGoalsInfoUseCase.kt | 537191581 |
package com.fitness.domain.usecase.user
import usecase.DataStateUseCase
abstract class DeleteBasicUserInfoUseCase : DataStateUseCase<DeleteBasicUserInfoUseCase.Params, Unit>(){
data class Params(val id: String)
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/DeleteBasicUserInfoUseCase.kt | 3585612655 |
package com.fitness.domain.usecase.user
import com.fitness.domain.model.user.UserBasicGoalsInfo
import usecase.DataStateUseCase
abstract class GetUserBasicGoalsInfoUseCase: DataStateUseCase<GetUserBasicGoalsInfoUseCase.Params, UserBasicGoalsInfo>(){
data class Params(val id: String)
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/GetUserBasicGoalsInfoUseCase.kt | 1849356815 |
package com.fitness.domain.usecase.user
import com.fitness.domain.model.user.UserPreferences
import usecase.DataStateUseCase
abstract class UpdateUserPreferencesUseCase: DataStateUseCase<UpdateUserPreferencesUseCase.Params, Unit>() {
data class Params(
val id: String,
val userPreferences: UserPreferences
)
}
| body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/UpdateUserPreferencesUseCase.kt | 506472819 |
package com.fitness.domain.usecase.user
import com.fitness.domain.model.user.UserFitnessLevel
import usecase.DataStateUseCase
abstract class GetUserBasicFitnessUseCase : DataStateUseCase<GetUserBasicFitnessUseCase.Params, UserFitnessLevel>(){
data class Params(val id: String)
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/GetUserBasicFitnessUseCase.kt | 2550659951 |
package com.fitness.domain.usecase.user
import com.fitness.domain.model.user.User
import usecase.DataStateUseCase
abstract class CreateUserUseCase: DataStateUseCase<CreateUserUseCase.Params, Unit>(){
data class Params(val userDomain: User)
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/CreateUserUseCase.kt | 2891355442 |
package com.fitness.domain.usecase.user
import com.fitness.domain.model.user.UserBasicInfo
import com.fitness.domain.model.user.UserPreferences
import usecase.DataStateUseCase
abstract class CreateBasicUserInfoUseCase: DataStateUseCase<CreateBasicUserInfoUseCase.Params, Unit>() {
data class Params(val userBasicInfoDomain: UserBasicInfo)
}
| body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/user/CreateBasicUserInfoUseCase.kt | 269340700 |
package com.fitness.domain.usecase.search
import com.fitness.domain.model.nutrition.Ingredient
import usecase.DataStateUseCase
abstract class EdamamIngredientSearchUseCase: DataStateUseCase<EdamamIngredientSearchUseCase.Params, List<Ingredient>>(){
data class Params(
val search: String? = null,
val brand: String? = null,
val health: String? = null,
val calories: String? = null,
val category: String? = null,
)
}
| body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/search/EdamamIngredientSearchUseCase.kt | 1405558243 |
package com.fitness.domain.usecase.search
import com.fitness.data.model.network.edamam.params.RecipeSearchParams
import com.fitness.domain.model.nutrition.Recipe
import usecase.DataStateUseCase
abstract class EdamamRecipeSearchUseCase : DataStateUseCase<EdamamRecipeSearchUseCase.Params, List<Recipe>>() {
data class Params(
val search: String,
val ingredients: String? = null,
val diet: List<String>? = null,
val health: List<String>? = null,
val cuisineType: List<String>? = null,
val mealType: List<String>? = null,
val dishType: List<String>? = null,
val calories: String? = null,
val time: String? = null,
val imageSize: List<String>? = null,
val glycemicIndex: String? = null,
val excluded: List<String>? = null,
val random: String? = null,
val co2EmissionsClass: String? = null,
val tag: List<String>? = null,
val language: String? = null,
)
protected fun Params.toSearchQuery(): RecipeSearchParams =
RecipeSearchParams(
query = search,
ingredients = ingredients,
diet = diet,
health = health,
cuisineType = cuisineType,
mealType = mealType,
dishType = dishType,
calories = calories,
time = time,
imageSize = imageSize,
glycemicIndex = glycemicIndex,
excluded = excluded,
random = random,
co2EmissionsClass = co2EmissionsClass,
tag = tag,
language = language
)
} | body-balance/domain/api/src/main/kotlin/com/fitness/domain/usecase/search/EdamamRecipeSearchUseCase.kt | 2281191620 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.