Feature/db case record

pom.xml

@@ -30,18 +30,16 @@
         <java.version>25</java.version>
     </properties>
     <dependencies>
-        <dependency>
-            <groupId>org.springframework.boot</groupId>
-            <artifactId>spring-boot-starter-webmvc</artifactId>
-        </dependency>
-
-
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-docker-compose</artifactId>
             <scope>runtime</scope>
             <optional>true</optional>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-webmvc</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.postgresql</groupId>
             <artifactId>postgresql</artifactId>
@@ -76,42 +74,10 @@
             <groupId>org.springframework.security</groupId>
             <artifactId>spring-security-webauthn</artifactId>
         </dependency>
-			<dependency>
-			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-docker-compose</artifactId>
-			<scope>runtime</scope>
-			<optional>true</optional>
-		</dependency>
-		<dependency>
-			<groupId>org.postgresql</groupId>
-			<artifactId>postgresql</artifactId>
-			<scope>runtime</scope>
-		</dependency>
-		<dependency>
-			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter-webmvc-test</artifactId>
-			<scope>test</scope>
-		</dependency>
-		<dependency>
-			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter-flyway</artifactId>
-		</dependency>
-		<dependency>
-			<groupId>org.flywaydb</groupId>
-			<artifactId>flyway-database-postgresql</artifactId>
-		</dependency>
-		<dependency>
-			<groupId>org.springframework.boot</groupId>
-			<artifactId>spring-boot-starter-data-jpa</artifactId>
-		</dependency>
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-security</artifactId>
 		</dependency>
-		<dependency>
-			<groupId>org.springframework.security</groupId>
-			<artifactId>spring-security-webauthn</artifactId>
-		</dependency>
 		<dependency>
 			<groupId>org.springframework.security</groupId>
 			<artifactId>spring-security-test</artifactId>

src/main/java/backendlab/team4you/caserecord/CaseNumberSequence.java

@@ -0,0 +1,71 @@
+package backendlab.team4you.caserecord;
+
+import backendlab.team4you.registry.Registry;
+import jakarta.persistence.*;
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotNull;
+
+import java.util.Objects;
+
+@Entity
+@Table(
+        name = "case_number_sequence",
+        uniqueConstraints = {
+                @UniqueConstraint(
+                        name = "uk_case_number_sequence_registry_year",
+                        columnNames = {"registry_id", "sequence_year"}
+                )
+        }
+)
+public class CaseNumberSequence {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @ManyToOne(optional = false, fetch = FetchType.LAZY)
+    @JoinColumn(name = "registry_id", nullable = false)
+    private Registry registry;
+
+    @Column(name = "sequence_year",nullable = false)
+    private Integer year;
+
+    @Column(name = "last_value", nullable = false)
+    @NotNull
+    @Min(0)
+    private Long lastValue;
+
+    protected CaseNumberSequence() {}
+
+    public CaseNumberSequence(Registry registry, Integer year, Long lastValue) {
+        this.registry = Objects.requireNonNull(registry, "registry is required");
+        this.year = Objects.requireNonNull(year, "year is required");
+        setLastValue(lastValue);
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public Registry getRegistry() {
+        return registry;
+    }
+
+    public Integer getYear() {
+        return year;
+    }
+
+    public Long getLastValue() {
+        return lastValue;
+    }
+
+    public void setLastValue(Long lastValue) {
+        if (lastValue == null) {
+            throw new IllegalArgumentException("lastValue is required");
+        }
+        if (lastValue < 0) {
+            throw new IllegalArgumentException("lastValue must be >= 0");
+        }
+        this.lastValue = lastValue;
+    }
+}

src/main/java/backendlab/team4you/caserecord/CaseNumberSequenceRepository.java

@@ -0,0 +1,16 @@
+package backendlab.team4you.caserecord;
+
+import backendlab.team4you.registry.Registry;
+import jakarta.persistence.LockModeType;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Lock;
+
+import java.util.Optional;
+
+public interface CaseNumberSequenceRepository extends JpaRepository<CaseNumberSequence, Long> {
+
+    Optional<CaseNumberSequence> findByRegistryAndYear(Registry registry, Integer year);
+
+    @Lock(LockModeType.PESSIMISTIC_WRITE)
+    Optional<CaseNumberSequence> findWithLockByRegistryAndYear(Registry registry, Integer year);
+}

src/main/java/backendlab/team4you/caserecord/CaseRecord.java

@@ -0,0 +1,173 @@
+package backendlab.team4you.caserecord;
+
+import backendlab.team4you.registry.Registry;
+import backendlab.team4you.user.UserEntity;
+import jakarta.persistence.*;
+
+import java.time.LocalDateTime;
+import java.util.Objects;
+
+@Entity
+@Table(
+        name = "case_record",
+        uniqueConstraints = {
+                @UniqueConstraint(name = "uk_case_record_case_number", columnNames = "case_number")
+        }
+)
+public class CaseRecord {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "case_number", nullable = false, length = 50, updatable = false)
+    private String caseNumber;
+
+    @ManyToOne(optional = false, fetch = FetchType.LAZY)
+    @JoinColumn(name = "registry_id", nullable = false)
+    private Registry registry;
+
+    @Column(nullable = false, length = 255)
+    private String title;
+
+    @Column(columnDefinition = "text")
+    private String description;
+
+    @Column(nullable = false, length = 50)
+    private String status;
+
+    @ManyToOne(optional = false, fetch = FetchType.LAZY)
+    @JoinColumn(name = "owner_user_id", nullable = false)
+    private UserEntity owner;
+
+    @ManyToOne(optional = false, fetch = FetchType.LAZY)
+    @JoinColumn(name = "assigned_user_id", nullable = false)
+    private UserEntity assignedUser;
+
+    @Column(name = "confidentiality_level", nullable = false, length = 50)
+    private String confidentialityLevel = "OPEN";
+
+    @Column(name = "opened_at", nullable = false)
+    private LocalDateTime openedAt;
+
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private LocalDateTime createdAt;
+
+    @Column(name = "updated_at")
+    private LocalDateTime updatedAt;
+
+    @Column(name = "closed_at")
+    private LocalDateTime closedAt;
+
+    protected CaseRecord() {
+    }
+
+    public CaseRecord(
+            Registry registry,
+            String title,
+            String description,
+            String status,
+            UserEntity owner,
+            UserEntity assignedUser,
+            String confidentialityLevel,
+            LocalDateTime openedAt
+    ) {
+        this.registry = Objects.requireNonNull(registry, "registry is required");
+        if (title == null || title.isBlank()) {
+            throw new IllegalArgumentException("title is required");
+        }
+        this.title = title.trim();
+        this.description = description;
+        this.status = (status == null || status.isBlank()) ? "OPEN" : status.trim();
+        this.owner = Objects.requireNonNull(owner, "owner is required");
+        this.assignedUser = Objects.requireNonNull(assignedUser, "assignedUser is required");
+        this.confidentialityLevel =
+                (confidentialityLevel == null || confidentialityLevel.isBlank())
+                        ? "OPEN"
+                        : confidentialityLevel.trim();
+
+        this.openedAt = openedAt;
+    }
+
+    @PrePersist
+    void onCreate() {
+        LocalDateTime now = LocalDateTime.now();
+        if (this.caseNumber == null || this.caseNumber.isBlank()) {
+            throw new IllegalStateException("caseNumber must be set before persisting");
+        }
+        this.createdAt = now;
+        if (this.openedAt == null) {
+            this.openedAt = now;
+        }
+    }
+
+    @PreUpdate
+    void onUpdate() {
+        this.updatedAt = LocalDateTime.now();
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public String getCaseNumber() {
+        return caseNumber;
+    }
+
+    public void setCaseNumber(String caseNumber) {
+        if (this.caseNumber != null) {
+            throw new IllegalStateException("caseNumber is immutable once set");
+        }
+        if (caseNumber == null || caseNumber.isBlank()) {
+            throw new IllegalArgumentException("caseNumber is required");
+        }
+        if (caseNumber.length() > 50) {
+            throw new IllegalArgumentException("caseNumber length must be <= 50");
+        }
+        this.caseNumber = caseNumber;
+    }
+
+    public Registry getRegistry() {
+        return registry;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public String getStatus() {
+        return status;
+    }
+
+    public UserEntity getOwner() {
+        return owner;
+    }
+
+    public UserEntity getAssignedUser() {
+        return assignedUser;
+    }
+
+    public String getConfidentialityLevel() {
+        return confidentialityLevel;
+    }
+
+    public LocalDateTime getOpenedAt() {
+        return openedAt;
+    }
+
+    public LocalDateTime getCreatedAt() {
+        return createdAt;
+    }
+
+    public LocalDateTime getUpdatedAt() {
+        return updatedAt;
+    }
+
+    public LocalDateTime getClosedAt() {
+        return closedAt;
+    }
+}

src/main/java/backendlab/team4you/caserecord/CaseRecordController.java

@@ -0,0 +1,34 @@
+package backendlab.team4you.caserecord;
+
+import jakarta.validation.Valid;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
+
+import java.net.URI;
+
+@RestController
+@RequestMapping("/api/case-records")
+
+public class CaseRecordController {
+    private final CaseRecordService caseRecordService;
+
+    public CaseRecordController(CaseRecordService caseRecordService) {
+        this.caseRecordService = caseRecordService;
+    }
+
+    @PostMapping
+    public ResponseEntity<CaseRecordResponseDto> createCaseRecord(
+            @Valid @RequestBody CaseRecordRequestDto requestDto) {
+        CaseRecordResponseDto responseDto = caseRecordService.createCaseRecord(requestDto);
+
+        URI location = ServletUriComponentsBuilder.fromCurrentRequest()
+                .path("/{id}")
+                .buildAndExpand(responseDto.id())
+                .toUri();
+        return ResponseEntity.created(location).body(responseDto);
+    }
+}

src/main/java/backendlab/team4you/caserecord/CaseRecordRepository.java

@@ -0,0 +1,12 @@
+package backendlab.team4you.caserecord;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface CaseRecordRepository extends JpaRepository<CaseRecord, Long> {
+
+    Optional<CaseRecord> findByCaseNumber(String caseNumber);
+
+    boolean existsByCaseNumber(String caseNumber);
+}