DigiDekan

Domain-Service in Spring Boot — berechnet alle SWS-Summen pro Professor mit Obergrenzen (Praxisseminar, Projektveranstaltung, Seminar Master, Betreuung), bestimmt Differenz zur Netto-Lehrverpflichtung und Status-Bewertung (erfüllt / Abweichung / starke Abweichung) und sammelt Warnungen bei überschrittenen Caps.

@Service
@RequiredArgsConstructor
public class DeputatService {

    private final DeputatsEinstellungenRepository einstellungenRepo;

    public DeputatsErgebnis berechneSummen(Professor prof) {
        DeputatsEinstellungen e = einstellungenRepo.getCurrent();

        // Lehrtätigkeiten nach Kategorie mit Obergrenzen
        Map<Kategorie, Double> nachKategorie = prof.getLehrtaetigkeiten().stream()
            .collect(Collectors.groupingBy(
                Lehrtaetigkeit::getKategorie,
                Collectors.summingDouble(Lehrtaetigkeit::getSws)));

        double praxisseminarRoh   = nachKategorie.getOrDefault(Kategorie.PRAXISSEMINAR, 0.0);
        double projektRoh         = nachKategorie.getOrDefault(Kategorie.PROJEKTVERANSTALTUNG, 0.0);
        double seminarMasterRoh   = nachKategorie.getOrDefault(Kategorie.SEMINAR_MASTER, 0.0);
        double sonstige           = nachKategorie.getOrDefault(Kategorie.SONSTIGE, 0.0);

        double praxisseminar = Math.min(praxisseminarRoh, e.getMaxSwsPraxisseminar());
        double projekt       = Math.min(projektRoh,       e.getMaxSwsProjekt());
        double seminarMaster = Math.min(seminarMasterRoh, e.getMaxSwsSeminarMaster());

        double swsLehre = sonstige + praxisseminar + projekt + seminarMaster;

        double lehrexport     = sumSws(prof.getLehrexporte());
        double vertretungen   = sumSws(prof.getVertretungen());
        double ermaessigungen = sumSws(prof.getErmaessigungen());

        double betreuungenRoh = sumSws(prof.getBetreuungen());
        double betreuungen    = Math.min(betreuungenRoh, e.getMaxSwsBetreuung());

        double gesamt   = swsLehre + lehrexport + vertretungen + betreuungen + ermaessigungen;
        double diff     = gesamt - prof.getNettoLehrverpflichtung();

        Bewertung bewertung = Math.abs(diff) <= 1.0 ? Bewertung.ERFUELLT
                            : Math.abs(diff) <= 3.0 ? Bewertung.ABWEICHUNG
                            : Bewertung.STARKE_ABWEICHUNG;

        List<String> warnungen = new ArrayList<>();
        if (praxisseminarRoh > e.getMaxSwsPraxisseminar()) {
            warnungen.add("Praxisseminar: %.1f SWS, max. %.1f angerechnet"
                .formatted(praxisseminarRoh, e.getMaxSwsPraxisseminar()));
        }
        if (betreuungenRoh > e.getMaxSwsBetreuung()) {
            warnungen.add("Betreuungen: %.1f SWS, max. %.1f angerechnet"
                .formatted(betreuungenRoh, e.getMaxSwsBetreuung()));
        }

        return DeputatsErgebnis.builder()
            .swsLehre(round(swsLehre))
            .gesamtdeputat(round(gesamt))
            .nettoLehrverpflichtung(round(prof.getNettoLehrverpflichtung()))
            .differenz(round(diff))
            .bewertung(bewertung)
            .warnungen(warnungen)
            .build();
    }
}

React-Stepper-Komponente implementiert einen 6-Stufen-Lifecycle (Entwurf → Eingereicht → In Prüfung → Geprüft → Ergebnis mitgeteilt → Abgeschlossen) mit Nachforderung-Handling, Zurückweisung-Anzeige, rollenbasierter Sichtbarkeit und Datums-Formatierung.

const TIMELINE_STEPS: TimelineStep[] = [
  { status: 'entwurf', label: 'Entwurf', dateField: 'created_at' },
  { status: 'eingereicht', label: 'Eingereicht', dateField: 'eingereicht_am' },
  { status: 'in_pruefung', label: 'In Pruefung', dateField: 'in_pruefung_am' },
  { status: 'geprueft', label: 'Geprueft', dateField: 'geprueft_am' },
  { status: 'ergebnis_mitgeteilt', label: 'Ergebnis mitgeteilt', dateField: 'ergebnis_mitgeteilt_am' },
  { status: 'abgeschlossen', label: 'Abgeschlossen', dateField: 'abgeschlossen_am' },
];

export default function AnerkennungStatusTimeline({ antrag, viewerRolle }: AnerkennungStatusTimelineProps) {
  const activeStepIndex = getActiveStepIndex(antrag.status);
  const isStudent = viewerRolle === 'student';

  return (
    <Box>
      <Stepper activeStep={activeStepIndex} orientation="vertical">
        {TIMELINE_STEPS.map((step, index) => {
          const dateValue = antrag[step.dateField] as string | undefined;
          const isCompleted = index < activeStepIndex;
          const isActive = index === activeStepIndex;
          const hasNachforderung =
            step.status === 'in_pruefung' &&
            (antrag.status === 'nachforderung' || antrag.nachforderung_am);

          return (
            <Step key={step.status} completed={isCompleted}>
              <StepLabel
                error={isActive && antrag.status === 'nachforderung'}
              >
                <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
                  <Typography variant="body2" sx={{ fontWeight: isActive ? 600 : 400 }}>
                    {step.label}
                  </Typography>
                  {isActive && antrag.status === 'nachforderung' && (
                    <Chip label="Nachforderung" size="small" color="error" variant="outlined" />
                  )}
                </Box>
              </StepLabel>
              <StepContent>
                {isActive && antrag.status === 'nachforderung' && antrag.nachforderung_grund && (
                  <Typography variant="body2" color="error.main">
                    Nachforderung: {antrag.nachforderung_grund}
                  </Typography>
                )}
                {step.status === 'eingereicht' && antrag.zurueckgewiesen_am && (
                  <Chip label="Zurueckgewiesen" size="small" color="warning" variant="outlined" />
                )}
              </StepContent>
            </Step>
          );
        })}
      </Stepper>
    </Box>
  );
}

Konfiguration der Rollen-basierten Zugriffskontrolle in Spring Security: granulare URL-Mapping-Regeln plus methoden-basierte Annotation per @PreAuthorize. JWT-Filter validiert Token aus dem Authorization-Header und befüllt den SecurityContext.

@Configuration
@EnableMethodSecurity(prePostEnabled = true)
@RequiredArgsConstructor
public class SecurityConfig {

    private final JwtAuthenticationFilter jwtFilter;

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(AbstractHttpConfigurer::disable)
            .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/auth/**").permitAll()
                .requestMatchers("/api/dekanat/**").hasRole("DEKAN")
                .requestMatchers("/api/deputat/own/**").hasAnyRole("DEKAN", "PROFESSOR")
                .requestMatchers("/api/anerkennung/pruefung/**").hasRole("DOZENT")
                .anyRequest().authenticated())
            .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class)
            .build();
    }
}

// Methoden-basierte Absicherung im Controller
@RestController
@RequestMapping("/api/semester")
@RequiredArgsConstructor
public class SemesterPlanungController {

    private final PlanungService planung;

    @PreAuthorize("hasAnyRole('DEKAN', 'VERWALTUNG')")
    @PostMapping("/{id}/freigabe")
    public ResponseEntity<PlanungDto> freigeben(@PathVariable Long id, Principal user) {
        return ResponseEntity.ok(planung.freigeben(id, user.getName()));
    }
}