com.opencredo.concourse.spring.demo.services.UserService Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of concourse-spring-boot-demo Show documentation
The newest version!
package com.opencredo.concourse.spring.demo.services;

import com.opencredo.concourse.domain.events.cataloguing.AggregateCatalogue;
import com.opencredo.concourse.domain.events.sourcing.EventSource;
import com.opencredo.concourse.domain.events.views.EventView;
import com.opencredo.concourse.domain.state.StateRepository;
import com.opencredo.concourse.mapping.events.methods.history.MappingEventHistoryFetcher;
import com.opencredo.concourse.spring.demo.events.UserEvents;
import com.opencredo.concourse.spring.demo.repositories.GroupState;
import com.opencredo.concourse.spring.demo.repositories.UserState;
import com.opencredo.concourse.spring.demo.views.UserView;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.Map.Entry;
import java.util.stream.Collectors;

import static java.util.stream.Collectors.toList;

@Component
public class UserService {

    private final EventSource eventSource;
    private final StateRepository userStateRepository;
    private final StateRepository groupStateRepository;
    private final AggregateCatalogue aggregateCatalogue;

    @Autowired
    public UserService(EventSource eventSource, StateRepository userStateRepository, StateRepository groupStateRepository, AggregateCatalogue aggregateCatalogue) {
        this.eventSource = eventSource;
        this.userStateRepository = userStateRepository;
        this.groupStateRepository = groupStateRepository;
        this.aggregateCatalogue = aggregateCatalogue;
    }

    public List getHistory(UUID userId) {
        return MappingEventHistoryFetcher.mapping(UserEvents.class).getHistory(eventSource, userId)
                .stream().map(EventView::of).collect(toList());
    }

    public boolean checkPassword(UUID userId, String passwordHash) {
        return userStateRepository.getState(userId)
                .filter(s -> !s.isDeleted())
                .map(userState -> userState.getPasswordHash().equals(passwordHash)).orElse(false);
    }

    public Optional getUser(UUID userId) {
        return userStateRepository.getState(userId)
                .filter(s -> !s.isDeleted())
                .map(user ->
                new UserView(
                        user.getId(),
                        user.getName(),
                        getGroupNames(user.getGroupIds())));
    }

    private Map getGroupNames(Collection groupIds) {
        return groupStateRepository.getStates(groupIds).entrySet().stream()
                .filter(e -> !e.getValue().isDeleted())
                .collect(Collectors.toMap(
                Entry::getKey,
                e -> e.getValue().getName()
        ));
    }

    public Map getUsers() {
        List users = aggregateCatalogue.getUuids("user");
        return userStateRepository.getStates(users).entrySet().stream()
                .filter(e -> !e.getValue().isDeleted())
                .collect(
                Collectors.toMap(
                        e -> e.getValue().getName(),
                        e -> "/api/v1/acl/users/" + e.getKey())
                );
    }
}