feat: Accommodation CRUD operations

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,27 +20,59 @@ repositories {
 }
 
 dependencies {
-	implementation("org.springframework.boot:spring-boot-starter-flyway")
-	implementation("org.springframework.boot:spring-boot-starter-actuator")
-	//implementation("org.springframework.boot:spring-boot-starter-security")
+	// Web and Core
 	implementation("org.springframework.boot:spring-boot-starter-webmvc")
+	implementation("org.springframework.boot:spring-boot-starter-actuator")
+	implementation("org.springframework.boot:spring-boot-starter-validation")
+
+
+	// Prometheus
+	implementation("io.micrometer:micrometer-registry-prometheus")
+
+	// 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")
+
+	// 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")
+
+	// 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")
-    //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")
-    //prometheus(metrics)
-    implementation("io.micrometer:micrometer-registry-prometheus")
-
-    runtimeOnly("org.postgresql:postgresql")
-	testImplementation("org.springframework.boot:spring-boot-starter-flyway-test")
-	//testImplementation("org.springframework.boot:spring-boot-starter-security-test")
+
+	// Test
+	testImplementation("org.springframework.boot:spring-boot-starter-test")
 	testImplementation("org.springframework.boot:spring-boot-starter-webmvc-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

@@ -2,4 +2,7 @@ SERVER_PORT=8080
 LOGSTASH_HOST=logstash:5000
 ZIPKIN_HOST=zipkin
 ZIPKIN_PORT=9411
-
+POSTGRES_HOST=devoops-postgres
+POSGTES_PORT=5432
+DB_USERNAME=accommodation-service
+DB_PASSWORD=accommodation-service-pass

src/main/java/com/devoops/accommodation/AccommodationApplication.java

@@ -2,12 +2,11 @@
 
 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 AccommodationApplication {
 
-	public static void main(String[] args) {
+	static void main(String[] args) {
 		SpringApplication.run(AccommodationApplication.class, args);
 	}
 

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

@@ -0,0 +1,12 @@
+package com.devoops.accommodation.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/accommodation/config/RoleAuthorizationInterceptor.java

@@ -0,0 +1,50 @@
+package com.devoops.accommodation.config;
+
+import com.devoops.accommodation.exception.ForbiddenException;
+import com.devoops.accommodation.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/accommodation/config/UserContext.java

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

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

@@ -0,0 +1,41 @@
+package com.devoops.accommodation.config;
+
+import com.devoops.accommodation.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/accommodation/config/WebConfig.java

@@ -0,0 +1,27 @@
+package com.devoops.accommodation.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/accommodation/controller/AccommodationController.java

@@ -0,0 +1,59 @@
+package com.devoops.accommodation.controller;
+
+import com.devoops.accommodation.config.RequireRole;
+import com.devoops.accommodation.config.UserContext;
+import com.devoops.accommodation.dto.request.CreateAccommodationRequest;
+import com.devoops.accommodation.dto.request.UpdateAccommodationRequest;
+import com.devoops.accommodation.dto.response.AccommodationResponse;
+import com.devoops.accommodation.service.AccommodationService;
+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/accommodation")
+@RequiredArgsConstructor
+public class AccommodationController {
+
+    private final AccommodationService accommodationService;
+
+    @PostMapping
+    @RequireRole("HOST")
+    public ResponseEntity<AccommodationResponse> create(
+            @Valid @RequestBody CreateAccommodationRequest request,
+            UserContext userContext) {
+        AccommodationResponse response = accommodationService.create(request, userContext);
+        return ResponseEntity.status(HttpStatus.CREATED).body(response);
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<AccommodationResponse> getById(@PathVariable UUID id) {
+        return ResponseEntity.ok(accommodationService.getById(id));
+    }
+
+    @GetMapping("/host/{hostId}")
+    public ResponseEntity<List<AccommodationResponse>> getByHostId(@PathVariable UUID hostId) {
+        return ResponseEntity.ok(accommodationService.getByHostId(hostId));
+    }
+
+    @PutMapping("/{id}")
+    @RequireRole("HOST")
+    public ResponseEntity<AccommodationResponse> update(
+            @PathVariable UUID id,
+            @Valid @RequestBody UpdateAccommodationRequest request,
+            UserContext userContext) {
+        return ResponseEntity.ok(accommodationService.update(id, request, userContext));
+    }
+
+    @DeleteMapping("/{id}")
+    @RequireRole("HOST")
+    public ResponseEntity<Void> delete(@PathVariable UUID id, UserContext userContext) {
+        accommodationService.delete(id, userContext);
+        return ResponseEntity.noContent().build();
+    }
+}

src/main/java/com/devoops/accommodation/dto/request/CreateAccommodationRequest.java

@@ -0,0 +1,35 @@
+package com.devoops.accommodation.dto.request;
+
+import com.devoops.accommodation.entity.AmenityType;
+import com.devoops.accommodation.entity.ApprovalMode;
+import com.devoops.accommodation.entity.PricingMode;
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+
+import java.util.Set;
+
+public record CreateAccommodationRequest(
+        @NotBlank(message = "Name is required")
+        String name,
+
+        @NotBlank(message = "Address is required")
+        String address,
+
+        @NotNull(message = "Minimum guests is required")
+        @Min(value = 1, message = "Minimum guests must be at least 1")
+        Integer minGuests,
+
+        @NotNull(message = "Maximum guests is required")
+        @Min(value = 1, message = "Maximum guests must be at least 1")
+        Integer maxGuests,
+
+        @NotNull(message = "Pricing mode is required")
+        PricingMode pricingMode,
+
+        @NotNull(message = "Approval mode is required")
+        ApprovalMode approvalMode,
+
+        Set<AmenityType> amenities
+) {
+}

src/main/java/com/devoops/accommodation/dto/request/UpdateAccommodationRequest.java

@@ -0,0 +1,27 @@
+package com.devoops.accommodation.dto.request;
+
+import com.devoops.accommodation.entity.AmenityType;
+import com.devoops.accommodation.entity.ApprovalMode;
+import com.devoops.accommodation.entity.PricingMode;
+import jakarta.validation.constraints.Min;
+
+import java.util.Set;
+
+public record UpdateAccommodationRequest(
+        String name,
+
+        String address,
+
+        @Min(value = 1, message = "Minimum guests must be at least 1")
+        Integer minGuests,
+
+        @Min(value = 1, message = "Maximum guests must be at least 1")
+        Integer maxGuests,
+
+        PricingMode pricingMode,
+
+        ApprovalMode approvalMode,
+
+        Set<AmenityType> amenities
+) {
+}

src/main/java/com/devoops/accommodation/dto/response/AccommodationResponse.java

@@ -0,0 +1,24 @@
+package com.devoops.accommodation.dto.response;
+
+import com.devoops.accommodation.entity.AmenityType;
+import com.devoops.accommodation.entity.ApprovalMode;
+import com.devoops.accommodation.entity.PricingMode;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.UUID;
+
+public record AccommodationResponse(
+        UUID id,
+        UUID hostId,
+        String name,
+        String address,
+        int minGuests,
+        int maxGuests,
+        PricingMode pricingMode,
+        ApprovalMode approvalMode,
+        List<AmenityType> amenities,
+        LocalDateTime createdAt,
+        LocalDateTime updatedAt
+) {
+}