seb4u Java Master Workbook

package com.seb4u.demo.workbook.core;

import java.nio.file.*;
import java.util.*;
import java.util.regex.Pattern;

public final class PackageGuardSolution {
    private static final Pattern ALLOWED = Pattern.compile(
            "package\\s+com\\.seb4u\\.demo(\\.(spring|jakarta))?(\\.[a-z0-9_]+)*\\s*;"
    );

    public static List<Path> findInvalidJavaFiles(Path root) throws Exception {
        try (var stream = Files.walk(root)) {
            return stream.filter(p -> p.toString().endsWith(".java"))
                    .filter(PackageGuardSolution::hasInvalidPackage)
                    .toList();
        }
    }

    private static boolean hasInvalidPackage(Path path) {
        try {
            String text = Files.readString(path);
            if (!text.contains("package ")) return false; // allowed for tiny snippets
            return !ALLOWED.matcher(text).find();
        } catch (Exception ex) {
            throw new IllegalStateException("Cannot read " + path, ex);
        }
    }
}

package com.seb4u.demo.workbook.core;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Currency;
import java.util.Objects;
import java.util.function.Function;

public record Money(BigDecimal amount, Currency currency) implements Comparable<Money> {
    public Money {
        Objects.requireNonNull(amount, "amount");
        Objects.requireNonNull(currency, "currency");
        amount = amount.setScale(currency.getDefaultFractionDigits(), RoundingMode.HALF_UP);
        if (amount.signum() < 0) throw new IllegalArgumentException("Money must not be negative");
    }

    public Money add(Money other) {
        requireSameCurrency(other);
        return new Money(amount.add(other.amount), currency);
    }

    public Money multiply(int factor) {
        if (factor < 0) throw new IllegalArgumentException("factor must not be negative");
        return new Money(amount.multiply(BigDecimal.valueOf(factor)), currency);
    }

    private void requireSameCurrency(Money other) {
        if (!currency.equals(other.currency)) {
            throw new IllegalArgumentException("Currency mismatch: " + currency + " vs " + other.currency);
        }
    }

    @Override public int compareTo(Money other) {
        requireSameCurrency(other);
        return amount.compareTo(other.amount);
    }

    public static Money eur(String amount) {
        return new Money(new BigDecimal(amount), Currency.getInstance("EUR"));
    }
}

package com.seb4u.demo.workbook.io;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.time.Instant;
import java.util.*;

public final class AtomicCsvImportSolution {
    private final Path inbox;
    private final Path processed;
    private final Path quarantine;

    public AtomicCsvImportSolution(Path root) throws IOException {
        this.inbox = root.resolve("inbox");
        this.processed = root.resolve("processed");
        this.quarantine = root.resolve("quarantine");
        Files.createDirectories(inbox);
        Files.createDirectories(processed);
        Files.createDirectories(quarantine);
    }

    public ImportReport importFile(Path input) throws IOException {
        Path safeInput = input.normalize().toAbsolutePath();
        if (!safeInput.startsWith(inbox.toAbsolutePath())) {
            throw new SecurityException("Path traversal attempt: " + input);
        }
        Path temp = Files.createTempFile(processed, "import-", ".tmp");
        int lines = 0;
        try (BufferedReader reader = Files.newBufferedReader(safeInput, StandardCharsets.UTF_8);
             BufferedWriter writer = Files.newBufferedWriter(temp, StandardCharsets.UTF_8)) {
            String line;
            while ((line = reader.readLine()) != null) {
                if (line.isBlank()) continue;
                String[] columns = line.split(",");
                if (columns.length < 3) throw new IOException("Invalid CSV line: " + line);
                writer.write(columns[0].trim() + ";" + columns[1].trim() + ";" + columns[2].trim());
                writer.newLine();
                lines++;
            }
        } catch (Exception ex) {
            Files.move(safeInput, quarantine.resolve(safeInput.getFileName()), StandardCopyOption.REPLACE_EXISTING);
            Files.deleteIfExists(temp);
            throw ex;
        }
        Path target = processed.resolve(safeInput.getFileName().toString().replace(".csv", ".normalized.csv"));
        Files.move(temp, target, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE);
        return new ImportReport(target, lines, Instant.now());
    }

    public record ImportReport(Path target, int importedLines, Instant finishedAt) {}
}

package com.seb4u.demo.workbook.architecture;

import java.time.Instant;
import java.util.UUID;

public final class PlaceOrderWorkflowSolution {
    public Result<OrderId> place(PlaceOrderCommand command, OrderRepository repository, PaymentPort payment, OutboxPort outbox) {
        if (command.customerId().isBlank() || command.totalCents() <= 0) {
            return Result.error("Invalid order command");
        }
        OrderId id = new OrderId(UUID.randomUUID().toString());
        PaymentDecision decision = payment.authorize(command.customerId(), command.totalCents());
        if (!decision.approved()) return Result.error("Payment rejected: " + decision.reason());
        repository.save(new Order(id, command.customerId(), command.totalCents(), Instant.now()));
        outbox.publish("OrderPlaced", id.value());
        return Result.ok(id);
    }

    public record PlaceOrderCommand(String customerId, long totalCents) {}
    public record OrderId(String value) {}
    public record Order(OrderId id, String customerId, long totalCents, Instant placedAt) {}
    public record PaymentDecision(boolean approved, String reason) {}
    public interface OrderRepository { void save(Order order); }
    public interface PaymentPort { PaymentDecision authorize(String customerId, long totalCents); }
    public interface OutboxPort { void publish(String type, String aggregateId); }

    public sealed interface Result<T> {
        record Ok<T>(T value) implements Result<T> {}
        record Error<T>(String message) implements Result<T> {}
        static <T> Result<T> ok(T value) { return new Ok<>(value); }
        static <T> Result<T> error(String message) { return new Error<>(message); }
    }
}

package com.seb4u.demo.workbook.commerceflow;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public final class IdempotentOutboxSolution {
    private final Map<String, OutboxEvent> eventsByKey = new ConcurrentHashMap<>();

    public boolean publishOnce(String idempotencyKey, String type, String aggregateId, String payload) {
        OutboxEvent event = new OutboxEvent(UUID.randomUUID().toString(), type, aggregateId, payload);
        return eventsByKey.putIfAbsent(idempotencyKey, event) == null;
    }

    public List<OutboxEvent> pending() {
        return List.copyOf(eventsByKey.values());
    }

    public record OutboxEvent(String id, String type, String aggregateId, String payload) {}
}

package com.seb4u.demo.spring.workbook;

import org.springframework.http.HttpStatus;
import org.springframework.http.ProblemDetail;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public final class ApiExceptionHandlerSolution {
    @ExceptionHandler(MethodArgumentNotValidException.class)
    ProblemDetail validation(MethodArgumentNotValidException ex) {
        ProblemDetail detail = ProblemDetail.forStatus(HttpStatus.BAD_REQUEST);
        detail.setTitle("Validation failed");
        detail.setDetail("Request body violates the API contract");
        detail.setProperty("fieldErrors", ex.getBindingResult().getFieldErrors().stream()
                .map(err -> err.getField() + ": " + err.getDefaultMessage())
                .toList());
        return detail;
    }

    @ExceptionHandler(IllegalArgumentException.class)
    ProblemDetail badRequest(IllegalArgumentException ex) {
        ProblemDetail detail = ProblemDetail.forStatus(HttpStatus.BAD_REQUEST);
        detail.setTitle("Invalid request");
        detail.setDetail(ex.getMessage());
        return detail;
    }
}

package com.seb4u.demo.workbook.interview;

import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Supplier;

public final class ThreadSafeMemoizerSolution<K, V> {
    private final ConcurrentHashMap<K, V> cache = new ConcurrentHashMap<>();

    public V getOrCompute(K key, Supplier<V> supplier) {
        return cache.computeIfAbsent(key, ignored -> supplier.get());
    }

    public int size() {
        return cache.size();
    }
}

package com.seb4u.demo.workbook.fullstack;

import java.util.List;

public record PageResponse<T>(
        int page,
        int size,
        long totalElements,
        List<T> items
) {
    public PageResponse {
        if (page < 0) throw new IllegalArgumentException("page must be >= 0");
        if (size <= 0 || size > 200) throw new IllegalArgumentException("size must be 1..200");
        if (totalElements < 0) throw new IllegalArgumentException("totalElements must be >= 0");
        items = List.copyOf(items);
    }

    public long totalPages() {
        return Math.max(1, (long) Math.ceil((double) totalElements / size));
    }
}

package com.seb4u.demo.workbook.cloud;

import java.time.Duration;
import java.time.Instant;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;

public final class IdempotencyStoreSolution {
    private final ConcurrentHashMap<String, Entry> entries = new ConcurrentHashMap<>();
    private final Duration ttl;

    public IdempotencyStoreSolution(Duration ttl) {
        this.ttl = ttl;
    }

    public Optional<String> getValidResponse(String key) {
        Entry entry = entries.get(key);
        if (entry == null) return Optional.empty();
        if (entry.createdAt().plus(ttl).isBefore(Instant.now())) {
            entries.remove(key, entry);
            return Optional.empty();
        }
        return Optional.of(entry.responseBody());
    }

    public boolean save(String key, String responseBody) {
        return entries.putIfAbsent(key, new Entry(responseBody, Instant.now())) == null;
    }

    private record Entry(String responseBody, Instant createdAt) {}
}

package com.seb4u.demo.workbook.algorithms;

import java.util.*;

public final class DijkstraSolution {
    public Map<String, Integer> shortestPaths(Map<String, List<Edge>> graph, String start) {
        Map<String, Integer> distance = new HashMap<>();
        PriorityQueue<Node> queue = new PriorityQueue<>(Comparator.comparingInt(Node::distance));
        distance.put(start, 0);
        queue.add(new Node(start, 0));
        while (!queue.isEmpty()) {
            Node current = queue.poll();
            if (current.distance() != distance.getOrDefault(current.name(), Integer.MAX_VALUE)) continue;
            for (Edge edge : graph.getOrDefault(current.name(), List.of())) {
                int nextDistance = current.distance() + edge.weight();
                if (nextDistance < distance.getOrDefault(edge.to(), Integer.MAX_VALUE)) {
                    distance.put(edge.to(), nextDistance);
                    queue.add(new Node(edge.to(), nextDistance));
                }
            }
        }
        return Map.copyOf(distance);
    }

    public record Edge(String to, int weight) {
        public Edge { if (weight < 0) throw new IllegalArgumentException("Dijkstra requires non-negative weights"); }
    }
    private record Node(String name, int distance) {}
}

package com.seb4u.demo.workbook.portfolio;

public final class PortfolioReadmeTemplate {
    public static String render(String projectName) {
        return """
                # %s

                ## Ziel
                Kurze fachliche Beschreibung und Lernziel.

                ## Architektur
                - Domain ohne Framework-Abhängigkeit
                - Application Layer mit Ports
                - Adapter für File, Spring oder Jakarta

                ## Start
                ```bash
                mvn test
                mvn -pl commerceflow-adapter-file exec:java
                ```

                ## Tests
                Unit Tests für Domain, Integration Tests für Adapter, Acceptance Tests für Hauptflows.

                ## Trade-offs
                Bewusste Vereinfachungen, technische Schulden und nächste Verbesserungen.
                """.formatted(projectName);
    }
}