PermissionByUserName.kt

package org.archtool.service.permission

import kotlinx.coroutines.flow.filterNotNull
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.toList
import org.archtool.configuration.VcsProperties
import org.archtool.data.exception.TokenGenerationError
import org.archtool.data.model.RepoPermission
import org.archtool.helper.PermissionHelper
import org.archtool.vcs.provider.VcsRepoLinkFormat
import org.archtool.repository.RepoRepository
import org.archtool.repository.RepoUserRepository
import org.archtool.repository.UserRepository
import org.archtool.service.SettingsService
import org.slf4j.LoggerFactory
import org.springframework.stereotype.Service

@Service
class PermissionByUserName(
    private val settingsService: SettingsService,
    private val repoRepository: RepoRepository,
    private val userRepository: UserRepository,
    private val repoUserRepository: RepoUserRepository,
    private val permissionHelper: PermissionHelper,
    private val vcsRepoLinkFormat: VcsRepoLinkFormat,
    private val vcsProperties: VcsProperties,
) {

    private val log = LoggerFactory.getLogger(javaClass)

    suspend fun fetch(userName: String): List<RepoPermission> {
        val sequence = settingsService.getActiveSequence()
            ?: throw TokenGenerationError("Не найден номер активной последовательности")
        log.trace("Получен sequence number {}", sequence)

        val user = userRepository.findByExternalUserIdAndSequence(userName, sequence)
        val personalPermissions = if(user != null) {
            log.trace("Получен пользователь: {} с userId: {} и ФИО: {} {}", userName, user.userId, user.lastname, user.name)
            repoUserRepository.findByKeyUserId(user.userId)
                .map { repoUserEntity ->
                    val repoEntity = repoRepository.findById(repoUserEntity.key.repoId)
                    if (repoEntity == null) {
                        log.error("Не найден репозиторий с ID: {} для пользователя: {}", repoUserEntity.key.repoId, userName)
                        return@map null
                    }
                    if (repoEntity.vcsProvider != vcsProperties.provider) {
                        log.warn("Репозиторий с ID {} для пользователя: {} найден, но другой провайдер, ожидался {} а получен {}, в итоговый список permission не попадёт",
                            repoUserEntity.key.repoId,
                            userName,
                            vcsProperties.provider,
                            repoEntity.vcsProvider
                        )
                        return@map null
                    }
                    val repoPrefix = vcsRepoLinkFormat.prefix(repoEntity)
                    RepoPermission(repoPrefix, repoUserEntity.permission)
                }.filterNotNull().toList()
        } else {
            log.warn("Не найден пользователь с externalUserId: {}  и sequence: {}", userName, sequence)
            emptyList()
        }

        return permissionHelper.mergeWithDefaultPermissions(personalPermissions, sequence)
    }

}