Feat/spring security setup

pom.xml

@@ -81,6 +81,10 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-security</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
+        </dependency>
         <dependency>
             <groupId>software.amazon.awssdk</groupId>
             <artifactId>s3</artifactId>

src/main/java/org/example/vet1177/controller/ActivityLogController.java

@@ -3,9 +3,9 @@
 import org.example.vet1177.dto.response.activitylog.ActivityLogResponse;
 import org.example.vet1177.entities.User;
 import org.example.vet1177.services.ActivityLogService;
-import org.example.vet1177.services.UserService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
@@ -18,26 +18,22 @@ public class ActivityLogController {
     private static final Logger log = LoggerFactory.getLogger(ActivityLogController.class);
 
     private final ActivityLogService activityLogService;
-    private final UserService userService;
 
-    public ActivityLogController(ActivityLogService activityLogService,
-                                 UserService userService) {
+    public ActivityLogController(ActivityLogService activityLogService) {
         this.activityLogService = activityLogService;
-        this.userService = userService;
     }
 
     // Hämta alla logs för ett MedicalRecord
     @GetMapping("/record/{recordId}")
     public List<ActivityLogResponse> getLogsByRecord(
             @PathVariable UUID recordId,
-            @RequestHeader("userId") UUID userId
+            @AuthenticationPrincipal User currentUser
     ) {
         log.info("GET /api/activity-logs/record/{}", recordId);
-        User user = userService.getUserEntityById(userId);
 
-        return activityLogService.getByRecord(recordId, user)
+        return activityLogService.getByRecord(recordId, currentUser)
                 .stream()
                 .map(ActivityLogResponse::from)
                 .toList();
     }
-}
+}

src/main/java/org/example/vet1177/controller/PetController.java

@@ -8,8 +8,8 @@
 import org.example.vet1177.services.PetService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.example.vet1177.services.UserService;
 import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
 import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
@@ -22,44 +22,42 @@ public class PetController {
     private static final Logger log = LoggerFactory.getLogger(PetController.class);
 
     private final PetService petService;
-    private final UserService userService;
 
-    public PetController(PetService petService, UserService userService) {
+    public PetController(PetService petService) {
         this.petService = petService;
-        this.userService = userService;
     }
 
-    //POST / pets - skapa nytt djur
+    //POST /pets - skapa nytt djur
     @PostMapping
     public PetResponse createPet(
-            // TODO: Ersätt med användare från autentiserad kontext (t.ex. JWT / Spring Security)
-            @RequestHeader UUID currentUserId,
+            @AuthenticationPrincipal User currentUser,
             @RequestParam(required = false) UUID ownerId,
             @Valid @RequestBody PetRequest request
     ) {
-        log.info("POST /pets - creating pet for currentUserId={} ownerId={}", currentUserId, ownerId);
-        Pet saved = petService.createPet(currentUserId, ownerId, request);
+        log.info("POST /pets - creating pet for userId={} ownerId={}", currentUser.getId(), ownerId);
+        Pet saved = petService.createPet(currentUser.getId(), ownerId, request);
         return toResponse(saved);
     }
 
-    // GET / pets/{petId} - hämta ett specifikt djur
+    // GET /pets/{petId} - hämta ett specifikt djur
     @GetMapping("/{petId}")
     public ResponseEntity<PetResponse> getPetById(
-            @RequestHeader UUID currentUserId,
+            @AuthenticationPrincipal User currentUser,
             @PathVariable UUID petId
     ) {
-        User currentUser = userService.getUserEntityById(currentUserId);
+        log.info("GET /pets/{}", petId);
         Pet pet = petService.getPetById(petId, currentUser);
         return ResponseEntity.ok(toResponse(pet));
     }
 
-    // GET/pets/owner/{ownerId} - hämta alla djur för en ägare
+    // GET /pets/owner/{ownerId} - hämta alla djur för en ägare
     @GetMapping("/owner/{ownerId}")
     public ResponseEntity<List<PetResponse>> getPetsByOwner(
-            @RequestHeader UUID currentUserId,
+            @AuthenticationPrincipal User currentUser,
             @PathVariable UUID ownerId
     ) {
-        List<PetResponse> pets = petService.getPetsByOwner(currentUserId, ownerId)
+        log.info("GET /pets/owner/{}", ownerId);
+        List<PetResponse> pets = petService.getPetsByOwner(currentUser.getId(), ownerId)
                 .stream()
                 .map(this::toResponse)
                 .toList();
@@ -69,21 +67,22 @@ public ResponseEntity<List<PetResponse>> getPetsByOwner(
     // PUT /pets/{petId} - uppdatera ett djur
     @PutMapping("/{petId}")
     public ResponseEntity<PetResponse> updatePet(
-            @RequestHeader UUID currentUserId,
+            @AuthenticationPrincipal User currentUser,
             @PathVariable UUID petId,
             @Valid @RequestBody PetRequest request
     ) {
-        Pet updated = petService.updatePet(currentUserId, petId, request);
+        log.info("PUT /pets/{}", petId);
+        Pet updated = petService.updatePet(currentUser.getId(), petId, request);
         return ResponseEntity.ok(toResponse(updated));
     }
 
     // DELETE /pets/{petId} - radera ett djur
     @DeleteMapping("/{petId}")
     public ResponseEntity<Void> deletePet(
-            @RequestHeader UUID currentUserId,
+            @AuthenticationPrincipal User currentUser,
             @PathVariable UUID petId
     ) {
-        User currentUser = userService.getUserEntityById(currentUserId);
+        log.info("DELETE /pets/{}", petId);
         petService.deletePet(petId, currentUser);
         return ResponseEntity.noContent().build();
     }
@@ -103,4 +102,4 @@ private PetResponse toResponse(Pet pet) {
         );
     }
 
-}
+}

src/main/java/org/example/vet1177/security/CustomUserDetailsService.java

@@ -0,0 +1,50 @@
+package org.example.vet1177.security;
+
+import org.example.vet1177.repository.UserRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Service;
+
+/**
+ * Bryggan mellan Spring Security och vår databas.
+ *
+ * Spring Security behöver veta hur man hämtar en användare givet ett "användarnamn".
+ * I vårt fall är "användarnamnet" email-adressen (det som står i JWT:ns subject-claim).
+ *
+ * Flödet:
+ *   JWT-token innehåller sub="sara@vet.se"
+ *       ↓
+ *   JwtAuthenticationFilter anropar loadUserByUsername("sara@vet.se")
+ *       ↓
+ *   Vi söker i databasen: userRepository.findByEmail("sara@vet.se")
+ *       ↓
+ *   Returnerar User-objektet (som implementerar UserDetails)
+ *       ↓
+ *   Spring Security sätter det i SecurityContext → @AuthenticationPrincipal fungerar
+ */
+@Service
+public class CustomUserDetailsService implements UserDetailsService {
+
+    private static final Logger log = LoggerFactory.getLogger(CustomUserDetailsService.class);
+
+    private final UserRepository userRepository;
+
+    public CustomUserDetailsService(UserRepository userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    @Override
+    public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
+        log.debug("Loading user by email={}", email);
+
+
+        return userRepository.findByEmail(email)
+                .orElseThrow(() -> {
+                    log.warn("User not found email={}", email);
+                    return new UsernameNotFoundException("Användare hittades inte: " + email);
+                });
+    }
+}

src/main/java/org/example/vet1177/security/JwtAuthenticationFilter.java

@@ -0,0 +1,128 @@
+package org.example.vet1177.security;
+
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.oauth2.jwt.Jwt;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.security.oauth2.jwt.JwtException;
+import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
+import org.springframework.stereotype.Component;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import java.io.IOException;
+
+/**
+ * Filter som körs EN gång per HTTP-request (OncePerRequestFilter).
+ *
+ * Vad händer steg för steg:
+ *
+ *   [Klient] → HTTP Request med "Authorization: Bearer eyJhbG..."
+ *       ↓
+ *   [JwtAuthenticationFilter]
+ *       1. Läser Authorization-headern
+ *       2. Extraherar token-strängen (allt efter "Bearer ")
+ *       3. Avkodar token via JwtService → får email + roll
+ *       4. Laddar User från DB via CustomUserDetailsService
+ *       5. Skapar ett Authentication-objekt och sätter det i SecurityContext
+ *       ↓
+ *   [Spring Security]
+ *       Kollar SecurityContext: finns en autentiserad användare?
+ *       Om ja → kontrollerar att användaren har rätt roll för endpointen
+ *       Om nej → returnerar 401 Unauthorized
+ *       ↓
+ *   [Controller]
+ *       @AuthenticationPrincipal User currentUser ← hämtas från SecurityContext
+ */
+@Component
+public class JwtAuthenticationFilter extends OncePerRequestFilter {
+
+    private static final Logger log = LoggerFactory.getLogger(JwtAuthenticationFilter.class);
+
+    private final JwtService jwtService;
+    private final CustomUserDetailsService userDetailsService;
+
+    public JwtAuthenticationFilter(JwtService jwtService, CustomUserDetailsService userDetailsService) {
+        this.jwtService = jwtService;
+        this.userDetailsService = userDetailsService;
+    }
+
+    @Override
+    protected void doFilterInternal(
+            HttpServletRequest request,
+            HttpServletResponse response,
+            FilterChain filterChain) throws ServletException, IOException {
+
+        // 1. Läs Authorization-headern
+        // Formatet är: "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+        String authHeader = request.getHeader("Authorization");
+
+        // Om headern saknas eller inte börjar med "Bearer " → skippa filtret.
+        // Requesten släpps vidare i kedjan. Om endpointen kräver auth
+        // kommer Spring Security att returnera 401 automatiskt.
+        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
+            filterChain.doFilter(request, response);
+            return;
+        }
+
+        // 2. Extrahera token-strängen (ta bort "Bearer " som är 7 tecken)
+        String token = authHeader.substring(7);
+
+        try {
+            // 3. Avkoda och validera token.
+            // Om signaturen inte stämmer eller token har gått ut kastar decode() JwtException.
+            Jwt jwt = jwtService.decode(token);
+
+            // 4. Hämta email från token (subject-claim)
+            String email = jwt.getSubject();
+
+            // Kolla att vi inte redan har autentiserat denna request
+            // (kan hända om flera filter kör i kedjan)
+            if (email != null && SecurityContextHolder.getContext().getAuthentication() == null) {
+
+                // 5. Ladda det fulla User-objektet från databasen.
+                // Vi behöver hela entiteten (med id, klinik, roll) för @AuthenticationPrincipal.
+                var userDetails = userDetailsService.loadUserByUsername(email);
+
+                // 6. Skapa ett Authentication-objekt.
+                // UsernamePasswordAuthenticationToken är Springs standardklass för "en autentiserad användare".
+                // - Första argumentet (principal) → User-objektet (det som @AuthenticationPrincipal ger)
+                // - Andra argumentet (credentials) → null (vi behöver inte lösenordet, token räcker)
+                // - Tredje argumentet (authorities) → rollerna (ROLE_VET, ROLE_ADMIN, etc.)
+                var authentication = new UsernamePasswordAuthenticationToken(
+                        userDetails, null, userDetails.getAuthorities()
+                );
+
+                // Kopplar request-detaljer (IP-adress, session-id) till autentiseringen — för loggning.
+                authentication.setDetails(
+                        new WebAuthenticationDetailsSource().buildDetails(request)
+                );
+
+                // 7. Sätt autentiseringen i SecurityContext.
+                // Från och med nu "vet" Spring Security att det finns en inloggad användare.
+                // Alla controllers kan hämta den via @AuthenticationPrincipal.
+                SecurityContextHolder.getContext().setAuthentication(authentication);
+
+                log.debug("Authenticated user email={} via JWT", email);
+            }
+
+        } catch (JwtException e) {
+            // Token är ogiltig (felaktig signatur, utgången, korrupt).
+            // Vi loggar och släpper vidare — Spring Security returnerar 401 automatiskt
+            // eftersom SecurityContext förblir tom.
+            log.warn("Invalid JWT token: {}", e.getMessage());
+        } catch (UsernameNotFoundException e) {
+            // Token är giltig men användaren finns inte längre i databasen
+            // (t.ex. raderad av admin medan tokenen fortfarande gäller).
+            log.warn("User from JWT no longer exists: {}", e.getMessage());
+        }
+
+        // Släpp vidare requesten till nästa filter i kedjan (och sedan till controllern)
+        filterChain.doFilter(request, response);
+    }
+}

src/main/java/org/example/vet1177/security/JwtProperties.java

@@ -0,0 +1,22 @@
+package org.example.vet1177.security;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+/**
+ * Läser JWT-konfiguration från application.properties.
+ *
+ * jwt.secret-key  → den hemliga nyckeln som används för att signera/verifiera tokens (HMAC SHA-256)
+ * jwt.expiration-ms → hur länge en token är giltig i millisekunder (86400000 = 24 timmar)
+ */
+@ConfigurationProperties(prefix = "jwt")
+public class JwtProperties {
+
+    private String secretKey;
+    private long expirationMs;
+
+    public String getSecretKey() { return secretKey; }
+    public void setSecretKey(String secretKey) { this.secretKey = secretKey; }
+
+    public long getExpirationMs() { return expirationMs; }
+    public void setExpirationMs(long expirationMs) { this.expirationMs = expirationMs; }
+}