Semmal/eeg_portal
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

extended user registration process, initial event based processing

Browse Source
This commit is contained in:
Bernhard Müller 2026-06-08 15:59:42 +02:00
parent 9bb354a805
commit a46566f8c6
11 changed files with 179 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
eeg_backend/pom.xml
View File

@ -42,6 +42,16 @@
<artifactId>springdoc-openapi-starter-webmvc-api</artifactId>
<version>3.0.3</version>
</dependency>
<dependency>
<groupId>org.mapstruct</groupId>
<artifactId>mapstruct</artifactId>
<version>1.6.3</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok-mapstruct-binding</artifactId>
<version>0.2.0</version>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
@ -99,6 +109,31 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>${maven.compiler.source}</source>
<target>${maven.compiler.target}</target>
<annotationProcessorPaths>
<path>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</path>
<path>
<groupId>org.projectlombok</groupId>
<artifactId>lombok-mapstruct-binding</artifactId>
<version>0.2.0</version>
</path>
<path>
<groupId>org.mapstruct</groupId>
<artifactId>mapstruct-processor</artifactId>
<version>1.6.3</version>
</path>
</annotationProcessorPaths>
<compilerArgs>
<arg>-Amapstruct.defaultComponentModel=spring</arg>
<arg>-Amapstruct.defaultInjectionStrategy=constructor</arg>
<arg>-Amapstruct.unmappedTargetPolicy=ERROR</arg>
</compilerArgs>
</configuration>
<executions>
<execution>
<id>default-compile</id>

8
eeg_backend/src/main/java/at/mueller/eeg/backend/common/config/event/EdaTopologyCheckEvent.java Normal file
View File

@ -0,0 +1,8 @@
package at.mueller.eeg.backend.common.config.event;
import java.util.UUID;
public record EdaTopologyCheckEvent(
UUID userId,
String atNumber
) {}

8
eeg_backend/src/main/java/at/mueller/eeg/backend/common/config/event/UserRegisteredEvent.java Normal file
View File

@ -0,0 +1,8 @@
package at.mueller.eeg.backend.common.config.event;
import java.util.UUID;
public record UserRegisteredEvent(
UUID userId,
String atNumber
) {}

33
eeg_backend/src/main/java/at/mueller/eeg/backend/community/event/listener/MeteringPointEventListener.java Normal file
View File

@ -0,0 +1,33 @@
package at.mueller.eeg.backend.community.event.listener;
import at.mueller.eeg.backend.common.config.event.EdaTopologyCheckEvent;
import at.mueller.eeg.backend.common.config.event.UserRegisteredEvent;
import at.mueller.eeg.backend.community.domain.MeteringPoint;
import at.mueller.eeg.backend.community.domain.PointType;
import at.mueller.eeg.backend.community.repository.MeteringPointRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.event.TransactionPhase;
import org.springframework.transaction.event.TransactionalEventListener;
@Component
@RequiredArgsConstructor
public class MeteringPointEventListener {
private final MeteringPointRepository meteringPointRepository;
private final ApplicationEventPublisher eventPublisher;
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
@Transactional
public void handleUserRegistered(UserRegisteredEvent event) {
MeteringPoint point = new MeteringPoint();
point.setUserId(event.userId());
point.setAtNumber(event.atNumber());
point.setType(PointType.CONSUMER);
meteringPointRepository.save(point);
eventPublisher.publishEvent(new EdaTopologyCheckEvent(point.getId(), event.atNumber()));
}
}

7
eeg_backend/src/main/java/at/mueller/eeg/backend/community/repository/MeteringPointRepository.java Normal file
View File

@ -0,0 +1,7 @@
package at.mueller.eeg.backend.community.repository;
import at.mueller.eeg.backend.community.domain.MeteringPoint;
import org.springframework.data.jpa.repository.JpaRepository;
public interface MeteringPointRepository extends JpaRepository<MeteringPoint, String> {
}

11
eeg_backend/src/main/java/at/mueller/eeg/backend/iam/api/AdminIamController.java
View File

@ -1,8 +1,10 @@
package at.mueller.eeg.backend.iam.api;
import at.mueller.eeg.backend.iam.api.dto.IamDtos.UserProfileResponse;
import at.mueller.eeg.backend.iam.repository.UserRepository;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
@ -14,16 +16,19 @@ import java.util.UUID;
@RequestMapping("/api/admin/users")
@PreAuthorize("hasRole('ADMIN')")
@Tag(name = "Admin IAM", description = "User-Verwaltung und Freigabe-Workflow")
@RequiredArgsConstructor
public class AdminIamController {
// private final UserManagementService userManagementService;
private final UserRepository userRepository;
@GetMapping("/pending")
@Operation(summary = "Lädt alle wartenden User",
description = "Zeigt User im Status PENDING inkl. der Ergebnisse des EDA-Netz-Checks.")
public ResponseEntity<List<UserProfileResponse>> getPendingUsers() {
// Logik: Finde alle User mit status = PENDING
return ResponseEntity.ok(List.of(/* ... */));
//return ResponseEntity.ok(userRepository.findAllByStatus(RegistrationStatus.PENDING));
return null;
}
@PostMapping("/{userId}/approve")

21
eeg_backend/src/main/java/at/mueller/eeg/backend/iam/mapper/PasswordHashMapper.java Normal file
View File

@ -0,0 +1,21 @@
package at.mueller.eeg.backend.iam.mapper;
import lombok.RequiredArgsConstructor;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;
import static at.mueller.eeg.backend.iam.mapper.UserMapperAnnotations.PasswordHash;
@Component
@RequiredArgsConstructor
public class PasswordHashMapper {
private final PasswordEncoder passwordEncoder;
@PasswordHash
public String hashPassword(String password) {
return passwordEncoder.encode(password);
}
}

28
eeg_backend/src/main/java/at/mueller/eeg/backend/iam/mapper/UserMapper.java Normal file
View File

@ -0,0 +1,28 @@
package at.mueller.eeg.backend.iam.mapper;
import at.mueller.eeg.backend.iam.api.dto.IamDtos;
import at.mueller.eeg.backend.iam.domain.User;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.MappingTarget;
@Mapper(
uses = PasswordHashMapper.class
)
public interface UserMapper {
@Mapping(target = "primaryAtNumber", ignore = true)
IamDtos.UserProfileResponse mapToDto(User user);
@Mapping(target = "status", constant = "PENDING")
@Mapping(target = "role", constant = "MEMBER")
@Mapping(target = "passwordHash", source = "password", qualifiedBy = UserMapperAnnotations.PasswordHash.class)
@Mapping(target = "id", ignore = true)
@Mapping(target = "iban", ignore = true)
@Mapping(target = "enabled", constant = "false")
@Mapping(target = "authorities", ignore = true)
User mapToEntity(IamDtos.RegistrationRequest request, @MappingTarget User user);
}

19
eeg_backend/src/main/java/at/mueller/eeg/backend/iam/mapper/UserMapperAnnotations.java Normal file
View File

@ -0,0 +1,19 @@
package at.mueller.eeg.backend.iam.mapper;
import lombok.experimental.UtilityClass;
import org.mapstruct.Qualifier;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@UtilityClass
public class UserMapperAnnotations {
@Qualifier
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.CLASS)
public @interface PasswordHash {
}
}

4
eeg_backend/src/main/java/at/mueller/eeg/backend/iam/repository/UserRepository.java
View File

@ -1,11 +1,15 @@
package at.mueller.eeg.backend.iam.repository;
import at.mueller.eeg.backend.iam.domain.RegistrationStatus;
import at.mueller.eeg.backend.iam.domain.User;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
import java.util.Optional;
public interface UserRepository extends JpaRepository<User, String> {
Optional<User> findByEmail(String email);
List<User> findAllByStatus(RegistrationStatus status);
}

21
eeg_backend/src/main/java/at/mueller/eeg/backend/iam/service/AuthService.java
View File

@ -1,14 +1,15 @@
package at.mueller.eeg.backend.iam.service;
import at.mueller.eeg.backend.iam.domain.RegistrationStatus;
import at.mueller.eeg.backend.common.config.event.UserRegisteredEvent;
import at.mueller.eeg.backend.iam.domain.User;
import at.mueller.eeg.backend.iam.mapper.UserMapper;
import at.mueller.eeg.backend.iam.repository.UserRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.oauth2.jose.jws.MacAlgorithm;
import org.springframework.security.oauth2.jwt.JwsHeader;
import org.springframework.security.oauth2.jwt.JwtClaimsSet;
@ -27,8 +28,9 @@ public class AuthService {
private final AuthenticationManager authenticationManager;
private final JwtEncoder jwtEncoder;
private final PasswordEncoder passwordEncoder;
private final UserRepository userRepository;
private final UserMapper userMapper;
private final ApplicationEventPublisher eventPublisher;
/**
* Verarbeitet den Login und gibt den JWT-Token als String zurück.
@ -57,17 +59,10 @@ public class AuthService {
throw new RuntimeException("E-Mail already exists!");
});
String hashedPassword = passwordEncoder.encode(request.password());
User newUser = new User();
newUser.setEmail(request.email());
newUser.setPasswordHash(hashedPassword);
newUser.setFirstName(request.firstName());
newUser.setLastName(request.lastName());
newUser.setStatus(RegistrationStatus.PENDING);
newUser.setEnabled(false);
User newUser = userMapper.mapToEntity(request, new User());
userRepository.save(newUser);
eventPublisher.publishEvent(new UserRegisteredEvent(newUser.getId(), request.atNumber()));
}
/**