Solution: UserService
class UserService(
private val userRepository: UserRepository,
private val userDtoFactory: UserDtoFactory,
private val tokenRepository: TokenRepository,
private val logger: Logger,
) {
private val userByIdCache: Cache<String, User> = cache {
clearAfterWrite = 1.minutes
clearAfterRead = 1.minutes
load { id: String ->
userRepository.getUser(id)
?.toUser()
?.also { userByKeyCache.store(it.key, it) }
}
}
private val userByKeyCache: Cache<String, User> = cache {
clearAfterWrite = 1.minutes
clearAfterRead = 1.minutes
load { key: String ->
userRepository.getUserByKey(key)
?.toUser()
?.also { userByIdCache.store(it.id, it) }
}
}
fun getUser(id: String): User? = userByIdCache.get(id)
fun getUserByKey(key: String): User? = userByKeyCache.get(key)
fun getToken(email: String, passwordHash: String): String =
userRepository.getUserByEmail(email)
?.takeIf { it.passwordHash == passwordHash }
?.let { tokenRepository.createToken(it.id, it.isAdmin) }
?: error("Wrong email or password")
fun updateUser(token: String, userPatch: UserPatch): User =
tokenRepository.getUserId(token)
?.let { userRepository.getUser(it) }
?.let { userDto ->
userDto.copy(
email = userPatch.email ?: userDto.email,
name = userPatch.name ?: userDto.name,
surname = userPatch.surname ?: userDto.surname,
)
}
?.also {
userRepository.updateUser(it)
userByIdCache.remove(it.id)
userByKeyCache.remove(it.key)
logger.log("User updated: $it")
}
?.toUser()
?: error("User not found")
fun addUser(token: String, addUser: AddUser): User {
if (!tokenRepository.isAdmin(token)) {
error("Only admin can add user")
}
return userDtoFactory.produceUserDto(addUser)
.also(userRepository::addUser)
.toUser()
.also { logger.log("User added: $it") }
}
fun userStatistics(token: String): UserStatistics {
if (!tokenRepository.isAdmin(token)) {
error("Only admin can get statistics")
}
return UserStatistics(
numberOfUsersCreatedEachDay = userRepository
.getAllUsers()
.groupingBy { it.creationTime.toLocalDate() }
.eachCount()
)
}
fun clearCache() {
userByIdCache.clear()
userByKeyCache.clear()
}
}
class UserDtoFactory(
private val timeProvider: TimeProvider,
private val uuidGenerator: UuidGenerator,
private val userKeyGenerator: UserKeyGenerator,
) {
fun produceUserDto(addUser: AddUser): UserDto = UserDto(
id = uuidGenerator.generate(),
key = userKeyGenerator
.findPublicKey(addUser.name, addUser.surname)
?: uuidGenerator.generate(),
email = addUser.email,
name = addUser.name,
surname = addUser.surname,
passwordHash = addUser.passwordHash,
isAdmin = false,
creationTime = timeProvider.now(),
)
}
class RealUserKeyGenerator(
private val userRepository: UserRepository,
): UserKeyGenerator {
override fun findPublicKey(
name: String,
surname: String
): String? = sequenceOf(
"$name$surname",
"$surname$name",
"$name${surname.first()}",
"${name.first()}$surname",
"$surname${name.first()}",
"${surname.first()}$name",
).map(::properKey)
.filter { it.length >= 4 }
.find(userRepository::isAvailableKey)
private fun properKey(original: String): String = original
.replace("[^0-9a-zA-Z]".toRegex(), "")
.lowercase()
.trim()
}
