UserService.java

/*
 * Copyright (C) 2022 Das Land Schleswig-Holstein vertreten durch den
 * Ministerpräsidenten des Landes Schleswig-Holstein
 * Staatskanzlei
 * Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
 *
 * Lizenziert unter der EUPL, Version 1.2 oder - sobald
 * diese von der Europäischen Kommission genehmigt wurden -
 * Folgeversionen der EUPL ("Lizenz");
 * Sie dürfen dieses Werk ausschließlich gemäß
 * dieser Lizenz nutzen.
 * Eine Kopie der Lizenz finden Sie hier:
 *
 * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
 *
 * Sofern nicht durch anwendbare Rechtsvorschriften
 * gefordert oder in schriftlicher Form vereinbart, wird
 * die unter der Lizenz verbreitete Software "so wie sie
 * ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
 * ausdrücklich oder stillschweigend - verbreitet.
 * Die sprachspezifischen Genehmigungen und Beschränkungen
 * unter der Lizenz sind dem Lizenztext zu entnehmen.
 */
package de.ozgcloud.user;

import java.util.Objects;
import java.util.Optional;
import java.util.stream.Stream;

import jakarta.enterprise.context.ApplicationScoped;

import org.apache.commons.lang3.StringUtils;

import de.ozgcloud.common.logging.OzgCloudLogging;
import de.ozgcloud.user.common.errorhandling.FunctionalException;
import de.ozgcloud.user.common.errorhandling.ResourceNotFoundException;
import de.ozgcloud.user.common.errorhandling.TechnicalException;
import de.ozgcloud.user.keycloak.KeycloakUserRemoteService;
import de.ozgcloud.user.settings.UserSettings;
import io.smallrye.mutiny.Uni;
import io.smallrye.mutiny.infrastructure.Infrastructure;
import lombok.RequiredArgsConstructor;

@ApplicationScoped
@OzgCloudLogging
@RequiredArgsConstructor
public class UserService {

	static final String MISSING_ORGANISATIONS_EINHEIT_ID_MESSAGE_TEMPLATE = "OrganisationsEinheitId ('%s') can not be null or empty";

	private final UserRepository repository;
	private final KeycloakUserRemoteService keycloakUserRemoteService;

	public User save(User user) {
		findUser(user).ifPresentOrElse(persistedUser -> repository.updateUser(addIdUser(user, persistedUser)),
				() -> saveNewUser(user));
		return repository.refresh(user);
	}

	void saveNewUser(User user) {
		if (Objects.isNull(user.getUserSettings())) {
			user.setUserSettings(UserSettings.createDefault());
		}
		repository.persist(user);
	}

	public Stream<User> findUsers(FindUserProfilesQuery query) {
		return repository.findUsers(query.getSearchBy(), query.getLimit());
	}

	public Stream<User> findActiveUsers(FindUserProfilesQuery query) {
		if (StringUtils.isNotBlank(query.getOrganisationsEinheitId())) {
			return repository.findUsersByDeletedAndOrganisationsEinheitId(
					query.getSearchBy(),
					false,
					query.getOrganisationsEinheitId(),
					query.getLimit());
		}
		return repository.findUsersByDeleted(query.getSearchBy(), false, query.getLimit());
	}

	public Stream<User> findInactiveUsers(FindUserProfilesQuery query) {
		if (StringUtils.isNotBlank(query.getOrganisationsEinheitId())) {
			return repository.findUsersByDeletedAndOrganisationsEinheitId(
					query.getSearchBy(),
					true,
					query.getOrganisationsEinheitId(),
					query.getLimit());
		}
		return repository.findUsersByDeleted(query.getSearchBy(), true, query.getLimit());
	}

	private Optional<User> findUser(User user) {
		return repository.findByExternalId(user.getExternalId()).or(() -> findByEmail(user.getEmail()));
	}

	private Optional<User> findByEmail(String email) {
		if (StringUtils.isNotBlank(email)) {
			return repository.findByEmail(email);
		}
		return Optional.empty();
	}

	private User addIdUser(User user, User persistedUser) {
		return user.toBuilder().id(persistedUser.getId()).build();
	}

	public void markUnsyncedUsersAsDeleted(long lastSyncTimestamp) {
		repository.updateUnsyncedUsers(lastSyncTimestamp);
	}

	public User getById(String id) {
		return repository.findById(id).orElseThrow(() -> new ResourceNotFoundException(User.class, id));
	}

	public User findByExternalId(String externalId) {
		return repository.findByKeycloakId(externalId)
				.or(() -> findInKeycloakAndSave(externalId))
				.orElseThrow(() -> new ResourceNotFoundException(User.class, externalId));
	}

	private Optional<User> findInKeycloakAndSave(String externalId) {
		return keycloakUserRemoteService.findUserById(externalId).map(this::saveAndSync);
	}

	public User saveAndSync(User user) {
		var saved = save(user);
		Uni.createFrom()
				.item(user)
				.runSubscriptionOn(Infrastructure.getDefaultWorkerPool())
				.subscribe()
				.with(u -> keycloakUserRemoteService.updateOzgCloudUserId(saved));
		return saved;
	}

	public Stream<String> findAllInactiveUserIds() {
		return repository.findAllDeletedUserIds();
	}

	public void deleteInactive(String userId) {
		var user = getById(userId);
		assertInactiveUser(user);
		repository.deleteById(userId);
	}

	void assertInactiveUser(User user) {
		if (!user.isDeleted()) {
			throw new TechnicalException(String.format("Deleting active users is not allowed [user id: %s].", user.getId().toHexString()));
		}
	}

	public Stream<User> findAllActiveUsersOfOrganisationsEinheit(String organisationsEinheitId) {
		if (StringUtils.isEmpty(organisationsEinheitId)) {
			throw new FunctionalException(() -> String.format(MISSING_ORGANISATIONS_EINHEIT_ID_MESSAGE_TEMPLATE, organisationsEinheitId));
		}
		return repository.findAllActiveByOrganisationsEinheitId(organisationsEinheitId);
	}
}