feat: Add reservation CRUD.

build.gradle.kts

@@ -1,5 +1,6 @@
 plugins {
 	java
+	jacoco
 	id("org.springframework.boot") version "4.0.1"
 	id("io.spring.dependency-management") version "1.1.7"
 }
@@ -19,26 +20,58 @@ repositories {
 }
 
 dependencies {
-	implementation("org.springframework.boot:spring-boot-starter-flyway")
-//	implementation("org.springframework.boot:spring-boot-starter-security")
+	// Web and Core
 	implementation("org.springframework.boot:spring-boot-starter-webmvc")
-    implementation("net.logstash.logback:logstash-logback-encoder:8.0")
-	implementation("org.flywaydb:flyway-database-postgresql")
-    implementation("org.springframework.boot:spring-boot-starter-actuator")
-    implementation("io.micrometer:micrometer-registry-prometheus")
-    //zipkin(tracing)
-    implementation("org.springframework.boot:spring-boot-micrometer-tracing-brave")
-    implementation("org.springframework.boot:spring-boot-starter-zipkin")
-    implementation("io.micrometer:micrometer-tracing-bridge-brave")
-    implementation("io.zipkin.reporter2:zipkin-reporter-brave")
+	implementation("org.springframework.boot:spring-boot-starter-actuator")
+	implementation("org.springframework.boot:spring-boot-starter-validation")
 
+	// Database
+	implementation("org.springframework.boot:spring-boot-starter-data-jpa")
+	implementation("org.springframework.boot:spring-boot-starter-flyway")
+	implementation("org.flywaydb:flyway-database-postgresql")
 	runtimeOnly("org.postgresql:postgresql")
-	testImplementation("org.springframework.boot:spring-boot-starter-flyway-test")
-//	testImplementation("org.springframework.boot:spring-boot-starter-security-test")
+
+	// Lombok
+	compileOnly("org.projectlombok:lombok")
+	annotationProcessor("org.projectlombok:lombok")
+
+	// MapStruct
+	implementation("org.mapstruct:mapstruct:1.6.3")
+	annotationProcessor("org.mapstruct:mapstruct-processor:1.6.3")
+	annotationProcessor("org.projectlombok:lombok-mapstruct-binding:0.2.0")
+
+	// Prometheus
+	implementation("io.micrometer:micrometer-registry-prometheus")
+
+	// Tracing (Zipkin)
+	implementation("org.springframework.boot:spring-boot-micrometer-tracing-brave")
+	implementation("org.springframework.boot:spring-boot-starter-zipkin")
+	implementation("io.micrometer:micrometer-tracing-bridge-brave")
+	implementation("io.zipkin.reporter2:zipkin-reporter-brave")
+
+	// Logging
+	implementation("net.logstash.logback:logstash-logback-encoder:8.0")
+
+	// Test
+	testImplementation("org.springframework.boot:spring-boot-starter-test")
 	testImplementation("org.springframework.boot:spring-boot-starter-webmvc-test")
+	testImplementation("org.springframework.boot:spring-boot-starter-flyway-test")
+	testImplementation("org.testcontainers:junit-jupiter:1.20.4")
+	testImplementation("org.testcontainers:postgresql:1.20.4")
+	testImplementation("io.rest-assured:rest-assured:5.5.0")
+	testCompileOnly("org.projectlombok:lombok")
+	testAnnotationProcessor("org.projectlombok:lombok")
 	testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }
 
 tasks.withType<Test> {
 	useJUnitPlatform()
+	finalizedBy(tasks.jacocoTestReport)
+}
+
+tasks.jacocoTestReport {
+	dependsOn(tasks.test)
+	reports {
+		xml.required = true
+	}
 }

environment/.local.env

@@ -1,4 +1,8 @@
 SERVER_PORT=8080
 LOGSTASH_HOST=logstash:5000
 ZIPKIN_HOST=zipkin
-ZIPKIN_PORT=9411
+ZIPKIN_PORT=9411
+POSTGRES_HOST=devoops-postgres
+POSTGRES_PORT=5432
+DB_USERNAME=reservation-service
+DB_PASSWORD=reservation-service-pass

src/main/java/com/devoops/reservation/ReservationApplication.java

@@ -2,9 +2,8 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
-import org.springframework.boot.jdbc.autoconfigure.DataSourceAutoConfiguration;
 
-@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
+@SpringBootApplication
 public class ReservationApplication {
 
 	public static void main(String[] args) {

src/main/java/com/devoops/reservation/config/RequireRole.java

@@ -0,0 +1,12 @@
+package com.devoops.reservation.config;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.METHOD, ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface RequireRole {
+    String[] value();
+}

src/main/java/com/devoops/reservation/config/RoleAuthorizationInterceptor.java

@@ -0,0 +1,49 @@
+package com.devoops.reservation.config;
+
+import com.devoops.reservation.exception.ForbiddenException;
+import com.devoops.reservation.exception.UnauthorizedException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import org.jspecify.annotations.NonNull;
+import org.springframework.stereotype.Component;
+import org.springframework.web.method.HandlerMethod;
+import org.springframework.web.servlet.HandlerInterceptor;
+
+import java.util.Arrays;
+
+@Component
+public class RoleAuthorizationInterceptor implements HandlerInterceptor {
+
+    @Override
+    public boolean preHandle(
+            @NonNull HttpServletRequest request,
+            @NonNull HttpServletResponse response,
+            @NonNull Object handler
+    ) {
+        if (!(handler instanceof HandlerMethod handlerMethod)) {
+            return true;
+        }
+
+        RequireRole methodAnnotation = handlerMethod.getMethodAnnotation(RequireRole.class);
+        RequireRole classAnnotation = handlerMethod.getBeanType().getAnnotation(RequireRole.class);
+
+        RequireRole requireRole = methodAnnotation != null ? methodAnnotation : classAnnotation;
+        if (requireRole == null) {
+            return true;
+        }
+
+        String role = request.getHeader("X-User-Role");
+        if (role == null) {
+            throw new UnauthorizedException("Missing authentication headers");
+        }
+
+        boolean hasRole = Arrays.stream(requireRole.value())
+                .anyMatch(r -> r.equalsIgnoreCase(role));
+
+        if (!hasRole) {
+            throw new ForbiddenException("Insufficient permissions");
+        }
+
+        return true;
+    }
+}

src/main/java/com/devoops/reservation/config/UserContext.java

@@ -0,0 +1,5 @@
+package com.devoops.reservation.config;
+
+import java.util.UUID;
+
+public record UserContext(UUID userId, String role) {}

src/main/java/com/devoops/reservation/config/UserContextResolver.java

@@ -0,0 +1,40 @@
+package com.devoops.reservation.config;
+
+import com.devoops.reservation.exception.UnauthorizedException;
+import org.jspecify.annotations.NonNull;
+import org.springframework.core.MethodParameter;
+import org.springframework.web.bind.support.WebDataBinderFactory;
+import org.springframework.web.context.request.NativeWebRequest;
+import org.springframework.web.method.support.HandlerMethodArgumentResolver;
+import org.springframework.web.method.support.ModelAndViewContainer;
+
+import java.util.UUID;
+
+public class UserContextResolver implements HandlerMethodArgumentResolver {
+
+    @Override
+    public boolean supportsParameter(MethodParameter parameter) {
+        return UserContext.class.isAssignableFrom(parameter.getParameterType());
+    }
+
+    @Override
+    public Object resolveArgument(
+            @NonNull MethodParameter parameter,
+            ModelAndViewContainer mavContainer,
+            NativeWebRequest webRequest,
+            WebDataBinderFactory binderFactory
+    ) {
+        String userId = webRequest.getHeader("X-User-Id");
+        String role = webRequest.getHeader("X-User-Role");
+
+        if (userId == null || role == null) {
+            throw new UnauthorizedException("Missing authentication headers");
+        }
+
+        try {
+            return new UserContext(UUID.fromString(userId), role);
+        } catch (IllegalArgumentException e) {
+            throw new UnauthorizedException("Invalid user ID format");
+        }
+    }
+}

src/main/java/com/devoops/reservation/config/WebConfig.java

@@ -0,0 +1,26 @@
+package com.devoops.reservation.config;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.method.support.HandlerMethodArgumentResolver;
+import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+import java.util.List;
+
+@Configuration
+@RequiredArgsConstructor
+public class WebConfig implements WebMvcConfigurer {
+
+    private final RoleAuthorizationInterceptor roleAuthorizationInterceptor;
+
+    @Override
+    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
+        resolvers.add(new UserContextResolver());
+    }
+
+    @Override
+    public void addInterceptors(InterceptorRegistry registry) {
+        registry.addInterceptor(roleAuthorizationInterceptor);
+    }
+}

src/main/java/com/devoops/reservation/controller/ReservationController.java

@@ -0,0 +1,63 @@
+package com.devoops.reservation.controller;
+
+import com.devoops.reservation.config.RequireRole;
+import com.devoops.reservation.config.UserContext;
+import com.devoops.reservation.dto.request.CreateReservationRequest;
+import com.devoops.reservation.dto.response.ReservationResponse;
+import com.devoops.reservation.service.ReservationService;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.UUID;
+
+@RestController
+@RequestMapping("/api/reservation")
+@RequiredArgsConstructor
+public class ReservationController {
+
+    private final ReservationService reservationService;
+
+    @PostMapping
+    @RequireRole("GUEST")
+    public ResponseEntity<ReservationResponse> create(
+            @Valid @RequestBody CreateReservationRequest request,
+            UserContext userContext) {
+        ReservationResponse response = reservationService.create(request, userContext);
+        return ResponseEntity.status(HttpStatus.CREATED).body(response);
+    }
+
+    @GetMapping("/{id}")
+    @RequireRole({"GUEST", "HOST"})
+    public ResponseEntity<ReservationResponse> getById(
+            @PathVariable UUID id,
+            UserContext userContext) {
+        return ResponseEntity.ok(reservationService.getById(id, userContext));
+    }
+
+
+    @GetMapping("/guest")
+    @RequireRole("GUEST")
+    public ResponseEntity<List<ReservationResponse>> getByGuest(UserContext userContext) {
+        return ResponseEntity.ok(reservationService.getByGuestId(userContext));
+    }
+
+    @GetMapping("/host")
+    @RequireRole("HOST")
+    public ResponseEntity<List<ReservationResponse>> getByHost(UserContext userContext) {
+        return ResponseEntity.ok(reservationService.getByHostId(userContext));
+    }
+
+
+    @DeleteMapping("/{id}")
+    @RequireRole("GUEST")
+    public ResponseEntity<Void> delete(
+            @PathVariable UUID id,
+            UserContext userContext) {
+        reservationService.deleteRequest(id, userContext);
+        return ResponseEntity.noContent().build();
+    }
+}

src/main/java/com/devoops/reservation/dto/request/CreateReservationRequest.java

@@ -0,0 +1,23 @@
+package com.devoops.reservation.dto.request;
+
+import jakarta.validation.constraints.*;
+
+import java.time.LocalDate;
+import java.util.UUID;
+
+public record CreateReservationRequest(
+        @NotNull(message = "Accommodation ID is required")
+        UUID accommodationId,
+
+        @NotNull(message = "Start date is required")
+        @FutureOrPresent(message = "Start date must be today or in the future")
+        LocalDate startDate,
+
+        @NotNull(message = "End date is required")
+        @Future(message = "End date must be in the future")
+        LocalDate endDate,
+
+        @NotNull(message = "Guest count is required")
+        @Min(value = 1, message = "Guest count must be at least 1")
+        Integer guestCount
+) {}

src/main/java/com/devoops/reservation/dto/response/ReservationResponse.java

@@ -0,0 +1,22 @@
+package com.devoops.reservation.dto.response;
+
+import com.devoops.reservation.entity.ReservationStatus;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+public record ReservationResponse(
+        UUID id,
+        UUID accommodationId,
+        UUID guestId,
+        UUID hostId,
+        LocalDate startDate,
+        LocalDate endDate,
+        int guestCount,
+        BigDecimal totalPrice,
+        ReservationStatus status,
+        LocalDateTime createdAt,
+        LocalDateTime updatedAt
+) {}

src/main/java/com/devoops/reservation/entity/BaseEntity.java

@@ -0,0 +1,36 @@
+package com.devoops.reservation.entity;
+
+import jakarta.persistence.*;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.experimental.SuperBuilder;
+import org.hibernate.annotations.CreationTimestamp;
+import org.hibernate.annotations.UpdateTimestamp;
+
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+@MappedSuperclass
+@Getter
+@Setter
+@NoArgsConstructor
+@SuperBuilder
+public abstract class BaseEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.UUID)
+    private UUID id;
+
+    @CreationTimestamp
+    @Column(updatable = false)
+    private LocalDateTime createdAt;
+
+    @UpdateTimestamp
+    private LocalDateTime updatedAt;
+
+    @Builder.Default
+    @Column(nullable = false)
+    private boolean isDeleted = false;
+}