Feature/frontend registry and caserecord

init-localstack.sh

@@ -1,4 +1,10 @@
 #!/bin/bash
 set -euo pipefail
+
 bucket="${AWS_BUCKET_NAME:-team4you-files}"
-awslocal s3api head-bucket --bucket "$bucket" 2>/dev/null || awslocal s3 mb "s3://$bucket"
+echo "checking/creating s3 bucket: $bucket"
+
+awslocal s3api head-bucket --bucket "$bucket" 2>/dev/null || awslocal s3 mb "s3://$bucket"
+
+echo "available buckets:"
+awslocal s3 ls

src/main/java/backendlab/team4you/Team4youApplication.java

@@ -2,6 +2,7 @@
 
 import backendlab.team4you.user.UserRepository;
 import backendlab.team4you.user.UserEntity;
+import backendlab.team4you.user.UserRole;
 import org.springframework.boot.ApplicationRunner;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
@@ -25,25 +26,25 @@ ApplicationRunner init(UserRepository repository, BCryptPasswordEncoder encoder)
 
 				UserEntity devAdmin = new UserEntity(
 						Bytes.fromBase64("YWRtaW4="),
-						"dev",           // name (username)
-						"admin"      // displayName
+						"dev",
+						"admin"
 				);
 
 				devAdmin.setPasswordHash(encoder.encode("123456"));
-				devAdmin.setRole("ROLE_ADMIN");
+				devAdmin.setRole(UserRole.ADMIN);
 				devAdmin.setEmail("devadmin@gmail.com");
 
 				repository.save(devAdmin);
 				System.out.println("✅ Admin created");
 
 				UserEntity devUser = new UserEntity(
 						Bytes.fromBase64("dXNlcg=="),
-						"user",           // name (username)
-						"user"      // displayName
+						"user",
+						"user"
 				);
 
 				devUser.setPasswordHash(encoder.encode("1234"));
-				devUser.setRole("ROLE_USER");
+				devUser.setRole(UserRole.USER);
 				devUser.setEmail("devuser@gmail.com");
 
 				repository.save(devUser);

src/main/java/backendlab/team4you/casefile/CaseFile.java

@@ -1,6 +1,7 @@
 package backendlab.team4you.casefile;
 
 import backendlab.team4you.caserecord.CaseRecord;
+import backendlab.team4you.common.ConfidentialityLevel;
 import jakarta.persistence.*;
 
 import java.time.LocalDateTime;
@@ -9,7 +10,11 @@
 @Table(
         name = "case_file",
         uniqueConstraints = {
-                @UniqueConstraint(name = "uk_case_file_s3_key", columnNames = "s3_key")
+                @UniqueConstraint(name = "uk_case_file_s3_key", columnNames = "s3_key"),
+                @UniqueConstraint(name = "uk_case_file_case_record_document_number",
+                        columnNames = {"case_record_id", "document_number"}),
+                @UniqueConstraint(name = "uk_case_file_document_reference",
+                        columnNames = "document_reference")
         }
 )
 public class CaseFile {
@@ -37,6 +42,16 @@ public class CaseFile {
     @Column(name = "uploaded_at", nullable = false)
     private LocalDateTime uploadedAt;
 
+    @Column(name = "document_number", nullable = false)
+    private int documentNumber;
+
+    @Column(name = "document_reference", nullable = false)
+    private String documentReference;
+
+    @Enumerated(EnumType.STRING)
+    @Column(name = "confidentiality_level", nullable = false, length = 50)
+    private ConfidentialityLevel confidentialityLevel;
+
     public String getS3Key() {
         return s3Key;
     }
@@ -92,4 +107,32 @@ public CaseRecord getCaseRecord() {
     public String getOriginalFilename() {
         return originalFileName;
     }
+
+    public int getDocumentNumber() {
+        return documentNumber;
+    }
+
+    public void setDocumentNumber(int documentNumber) {
+        this.documentNumber = documentNumber;
+    }
+
+    public String getDocumentReference() {
+        return documentReference;
+    }
+
+    public void setDocumentReference(String documentReference) {
+        this.documentReference = documentReference;
+    }
+
+    public ConfidentialityLevel getConfidentialityLevel() {
+        return confidentialityLevel;
+    }
+
+    public void setConfidentialityLevel(ConfidentialityLevel confidentialityLevel) {
+        this.confidentialityLevel = confidentialityLevel;
+    }
+
+    public boolean isConfidential() {
+        return confidentialityLevel == ConfidentialityLevel.CONFIDENTIAL;
+    }
 }

src/main/java/backendlab/team4you/casefile/CaseFileController.java

@@ -1,62 +1,79 @@
 package backendlab.team4you.casefile;
 
+import backendlab.team4you.common.ConfidentialityLevel;
+import backendlab.team4you.user.UserEntity;
+import backendlab.team4you.user.UserService;
+import org.springframework.http.ContentDisposition;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
 import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;
-import org.springframework.http.ContentDisposition;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
+import java.security.Principal;
 import java.util.List;
 
 @RestController
 @RequestMapping("/api/cases/{caseRecordId}/files")
 public class CaseFileController {
 
     private final CaseFileService caseFileService;
+    private final UserService userService;
 
-    public CaseFileController(CaseFileService caseFileService) {
+    public CaseFileController(CaseFileService caseFileService, UserService userService) {
         this.caseFileService = caseFileService;
+        this.userService = userService;
     }
 
     @PostMapping
     public ResponseEntity<CaseFileResponseDto> uploadFile(
             @PathVariable Long caseRecordId,
-            @RequestParam("file") MultipartFile file
+            @RequestParam("file") MultipartFile file,
+            @RequestParam("confidentialityLevel") ConfidentialityLevel confidentialityLevel,
+            Principal principal
     ) throws IOException {
-        CaseFile savedFile = caseFileService.uploadFile(caseRecordId, file);
+        UserEntity currentUser = userService.getCurrentUser(principal);
+        CaseFile savedFile = caseFileService.uploadFile(caseRecordId, file, confidentialityLevel, currentUser);
         return ResponseEntity.ok(CaseFileResponseDto.from(savedFile));
     }
 
     @GetMapping
-    public ResponseEntity <List<CaseFileResponseDto>> listFiles(@PathVariable Long caseRecordId) {
-        List<CaseFileResponseDto> files = caseFileService.listFiles(caseRecordId).stream()
-                .map(CaseFileResponseDto::from)
-                .toList();
+    public ResponseEntity<List<CaseFileListItemDto>> listFiles(
+            @PathVariable Long caseRecordId,
+            Principal principal
+    ) {
+        UserEntity currentUser = userService.getCurrentUser(principal);
+
+        List<CaseFileListItemDto> files =
+                caseFileService.listFileItemsForViewer(caseRecordId, currentUser);
 
         return ResponseEntity.ok(files);
     }
 
     @GetMapping("/{fileId}")
     public ResponseEntity<StreamingResponseBody> downloadFile(
             @PathVariable Long caseRecordId,
-            @PathVariable Long fileId
+            @PathVariable Long fileId,
+            Principal principal
     ) {
-        CaseFile caseFile = caseFileService.getCaseFile(caseRecordId, fileId);
+        UserEntity currentUser = userService.getCurrentUser(principal);
+        CaseFile caseFile = caseFileService.getCaseFileForViewer(caseRecordId, fileId, currentUser);
 
         MediaType mediaType = MediaType.APPLICATION_OCTET_STREAM;
         if (caseFile.getContentType() != null && !caseFile.getContentType().isBlank()) {
             mediaType = MediaType.parseMediaType(caseFile.getContentType());
         }
+
         StreamingResponseBody body = outputStream -> {
-            try (InputStream stream = caseFileService.downloadFile(caseRecordId, fileId)) {
+            try (InputStream stream = caseFileService.downloadFile(caseRecordId, fileId, currentUser)) {
                 stream.transferTo(outputStream);
             }
         };
+
         return ResponseEntity.ok()
                 .header(
                         HttpHeaders.CONTENT_DISPOSITION,
@@ -72,9 +89,11 @@ public ResponseEntity<StreamingResponseBody> downloadFile(
     @DeleteMapping("/{fileId}")
     public ResponseEntity<Void> deleteFile(
             @PathVariable Long caseRecordId,
-            @PathVariable Long fileId
+            @PathVariable Long fileId,
+            Principal principal
     ) {
-        caseFileService.deleteFile(caseRecordId, fileId);
+        UserEntity currentUser = userService.getCurrentUser(principal);
+        caseFileService.deleteFile(caseRecordId, fileId, currentUser);
         return ResponseEntity.noContent().build();
     }
 }

src/main/java/backendlab/team4you/casefile/CaseFileListItemDto.java

@@ -0,0 +1,10 @@
+package backendlab.team4you.casefile;
+
+public record CaseFileListItemDto(
+        Long id,
+        String documentReference,
+        String displayName,
+        boolean confidential,
+        boolean canDownload
+) {
+}

src/main/java/backendlab/team4you/casefile/CaseFileRepository.java

@@ -1,11 +1,15 @@
 package backendlab.team4you.casefile;
 
+import jakarta.persistence.LockModeType;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Lock;
 
 import java.util.List;
 import java.util.Optional;
 
 public interface CaseFileRepository extends JpaRepository<CaseFile, Long> {
-    List<CaseFile> findByCaseRecordId(Long caseRecordId);
+    List<CaseFile> findByCaseRecordIdOrderByDocumentNumberAsc(Long caseRecordId);
     Optional<CaseFile> findByIdAndCaseRecordId(Long id, Long caseRecordId);
+    @Lock(LockModeType.PESSIMISTIC_WRITE)
+    Optional<CaseFile> findTopByCaseRecordIdOrderByDocumentNumberDesc(Long caseRecordId);
 }

src/main/java/backendlab/team4you/casefile/CaseFileResponseDto.java

@@ -1,21 +1,29 @@
 package backendlab.team4you.casefile;
 
+import backendlab.team4you.common.ConfidentialityLevel;
+
 import java.time.LocalDateTime;
 
 public record CaseFileResponseDto(
         Long id,
         String originalFilename,
         String contentType,
         long size,
-        LocalDateTime uploadedAt
+        LocalDateTime uploadedAt,
+        int documentNumber,
+        String documentReference,
+        ConfidentialityLevel confidentialityLevel
 ) {
     public static CaseFileResponseDto from(CaseFile caseFile) {
         return new CaseFileResponseDto(
                 caseFile.getId(),
                 caseFile.getOriginalFilename(),
                 caseFile.getContentType(),
                 caseFile.getSize(),
-                caseFile.getUploadedAt()
+                caseFile.getUploadedAt(),
+                caseFile.getDocumentNumber(),
+                caseFile.getDocumentReference(),
+                caseFile.getConfidentialityLevel()
         );
     }
 }