✨ implement ingredient registration

backend/src/main/java/net/pengcook/ingredient/domain/Ingredient.java

@@ -1,16 +1,29 @@
 package net.pengcook.ingredient.domain;
 
+import static lombok.AccessLevel.PRIVATE;
+import static lombok.AccessLevel.PROTECTED;
+
 import jakarta.persistence.Entity;
 import jakarta.persistence.GeneratedValue;
 import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
 
 @Entity
+@NoArgsConstructor(access = PROTECTED)
+@AllArgsConstructor(access = PRIVATE)
+@Getter
 public class Ingredient {
 
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private long id;
 
     private String name;
+
+    public Ingredient(String name) {
+        this(0L, name);
+    }
 }

backend/src/main/java/net/pengcook/ingredient/domain/IngredientRecipe.java

@@ -1,5 +1,8 @@
 package net.pengcook.ingredient.domain;
 
+import static lombok.AccessLevel.PRIVATE;
+import static lombok.AccessLevel.PROTECTED;
+
 import jakarta.persistence.Entity;
 import jakarta.persistence.EnumType;
 import jakarta.persistence.Enumerated;
@@ -8,9 +11,15 @@
 import jakarta.persistence.Id;
 import jakarta.persistence.JoinColumn;
 import jakarta.persistence.ManyToOne;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
 import net.pengcook.recipe.domain.Recipe;
 
 @Entity
+@NoArgsConstructor(access = PROTECTED)
+@AllArgsConstructor(access = PRIVATE)
+@Getter
 public class IngredientRecipe {
 
     @Id
@@ -27,4 +36,8 @@ public class IngredientRecipe {
 
     @Enumerated(EnumType.STRING)
     private Requirement requirement;
+
+    public IngredientRecipe(Ingredient ingredient, Recipe recipe, Requirement requirement) {
+        this(0L, ingredient, recipe, requirement);
+    }
 }

backend/src/main/java/net/pengcook/ingredient/domain/IngredientSubstitution.java

@@ -1,14 +1,24 @@
 package net.pengcook.ingredient.domain;
 
+import static lombok.AccessLevel.PRIVATE;
+import static lombok.AccessLevel.PROTECTED;
+
 import jakarta.persistence.Entity;
 import jakarta.persistence.GeneratedValue;
 import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
 import jakarta.persistence.JoinColumn;
 import jakarta.persistence.ManyToOne;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
 
 @Entity
+@NoArgsConstructor(access = PROTECTED)
+@AllArgsConstructor(access = PRIVATE)
+@Getter
 public class IngredientSubstitution {
+
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
     private long id;
@@ -20,4 +30,8 @@ public class IngredientSubstitution {
     @ManyToOne
     @JoinColumn(name = "ingredient_id")
     private Ingredient ingredient;
+
+    public IngredientSubstitution(IngredientRecipe ingredientRecipe, Ingredient ingredient) {
+        this(0L, ingredientRecipe, ingredient);
+    }
 }

backend/src/main/java/net/pengcook/ingredient/dto/IngredientCreateRequest.java

@@ -0,0 +1,35 @@
+package net.pengcook.ingredient.dto;
+
+import java.util.List;
+import net.pengcook.ingredient.domain.Requirement;
+import net.pengcook.ingredient.exception.InvalidNameException;
+
+public record IngredientCreateRequest(
+        String name,
+        Requirement requirement,
+        List<String> substitutions
+) {
+
+    public IngredientCreateRequest {
+        validateName(name);
+        if (requirement == Requirement.ALTERNATIVE) {
+            validateSubstitutions(substitutions);
+        }
+    }
+
+    private void validateName(String name) {
+        if (name == null || name.isBlank()) {
+            throw new InvalidNameException("name cannot be null or empty");
+        }
+    }
+
+    private void validateSubstitutions(List<String> substitutions) {
+        if (substitutions == null) {
+            throw new InvalidNameException("substitutions cannot be null");
+        }
+        for (String substitution : substitutions) {
+            validateName(substitution);
+        }
+    }
+
+}

backend/src/main/java/net/pengcook/ingredient/exception/InvalidNameException.java

@@ -0,0 +1,10 @@
+package net.pengcook.ingredient.exception;
+
+import org.springframework.http.HttpStatus;
+
+public class InvalidNameException extends IngredientException {
+
+    public InvalidNameException(String message) {
+        super(HttpStatus.BAD_REQUEST, message);
+    }
+}

backend/src/main/java/net/pengcook/ingredient/repository/IngredientRecipeRepository.java

@@ -0,0 +1,10 @@
+package net.pengcook.ingredient.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import net.pengcook.ingredient.domain.IngredientRecipe;
+
+@Repository
+public interface IngredientRecipeRepository extends JpaRepository<IngredientRecipe, Long> {
+}

backend/src/main/java/net/pengcook/ingredient/repository/IngredientRepository.java

@@ -0,0 +1,12 @@
+package net.pengcook.ingredient.repository;
+
+import java.util.Optional;
+import net.pengcook.ingredient.domain.Ingredient;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public interface IngredientRepository extends JpaRepository<Ingredient, Long> {
+
+    Optional<Ingredient> findByName(String name);
+}

backend/src/main/java/net/pengcook/ingredient/repository/IngredientSubstitutionRepository.java

@@ -0,0 +1,10 @@
+package net.pengcook.ingredient.repository;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import net.pengcook.ingredient.domain.IngredientSubstitution;
+
+@Repository
+public interface IngredientSubstitutionRepository extends JpaRepository<IngredientSubstitution, Long> {
+}

backend/src/main/java/net/pengcook/ingredient/service/IngredientRecipeService.java

@@ -0,0 +1,24 @@
+package net.pengcook.ingredient.service;
+
+import org.springframework.stereotype.Service;
+
+import net.pengcook.ingredient.domain.Ingredient;
+import net.pengcook.ingredient.domain.IngredientRecipe;
+import net.pengcook.ingredient.domain.Requirement;
+import net.pengcook.ingredient.repository.IngredientRecipeRepository;
+import net.pengcook.recipe.domain.Recipe;
+
+import lombok.RequiredArgsConstructor;
+
+@Service
+@RequiredArgsConstructor
+public class IngredientRecipeService {
+
+    private final IngredientRecipeRepository ingredientRecipeRepository;
+
+    public IngredientRecipe save(Ingredient ingredient, Recipe recipe, Requirement requirement) {
+        IngredientRecipe ingredientRecipe = new IngredientRecipe(ingredient, recipe, requirement);
+        return ingredientRecipeRepository.save(ingredientRecipe);
+    }
+
+}

backend/src/main/java/net/pengcook/ingredient/service/IngredientService.java

@@ -0,0 +1,91 @@
+package net.pengcook.ingredient.service;
+
+
+import jakarta.transaction.Transactional;
+import java.util.HashSet;
+import java.util.List;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import net.pengcook.ingredient.domain.Ingredient;
+import net.pengcook.ingredient.domain.IngredientRecipe;
+import net.pengcook.ingredient.domain.Requirement;
+import net.pengcook.ingredient.dto.IngredientCreateRequest;
+import net.pengcook.ingredient.exception.InvalidNameException;
+import net.pengcook.ingredient.repository.IngredientRepository;
+import net.pengcook.recipe.domain.Recipe;
+import org.springframework.stereotype.Service;
+
+@Service
+@Transactional
+@RequiredArgsConstructor
+@Getter
+public class IngredientService {
+
+    private final IngredientRepository ingredientRepository;
+    private final IngredientRecipeService ingredientRecipeService;
+    private final IngredientSubstitutionService ingredientSubstitutionService;
+
+    public void register(List<IngredientCreateRequest> requests, Recipe recipe) {
+        validateDuplicateNames(getIngredientNames(requests));
+        for (IngredientCreateRequest request : requests) {
+            registerOne(request, recipe);
+        }
+    }
+
+    private void registerOne(IngredientCreateRequest request, Recipe recipe) {
+        Ingredient ingredient = registerOrGetIngredient(request.name());
+        IngredientRecipe ingredientRecipe = registerIngredientRecipe(recipe, request, ingredient);
+
+        if (request.requirement() == Requirement.ALTERNATIVE) {
+            registerSubstitution(request, ingredientRecipe);
+        }
+    }
+
+    private Ingredient registerOrGetIngredient(String ingredientName) {
+        String name = ingredientName.toLowerCase();
+
+        return ingredientRepository.findByName(name)
+                .orElseGet(() -> ingredientRepository.save(new Ingredient(name)));
+    }
+
+    private IngredientRecipe registerIngredientRecipe(
+            Recipe recipe,
+            IngredientCreateRequest request,
+            Ingredient ingredient
+    ) {
+        return ingredientRecipeService.save(ingredient, recipe, request.requirement());
+    }
+
+    private void registerSubstitution(IngredientCreateRequest request, IngredientRecipe ingredientRecipe) {
+        List<String> substitutionNames = request.substitutions();
+        validateDuplicateNames(substitutionNames);
+
+        for (String substitutionName : substitutionNames) {
+            Ingredient substitution = registerOrGetIngredient(substitutionName);
+            registerIngredientSubstitution(ingredientRecipe, substitution);
+        }
+    }
+
+    private void registerIngredientSubstitution(IngredientRecipe ingredientRecipe, Ingredient substitution) {
+        ingredientSubstitutionService.save(ingredientRecipe, substitution);
+    }
+
+    private List<String> getIngredientNames(List<IngredientCreateRequest> requests) {
+        return requests.stream()
+                .map(IngredientCreateRequest::name)
+                .map(String::toLowerCase)
+                .toList();
+    }
+
+    private void validateDuplicateNames(List<String> names) {
+        if (hasDuplicateName(names)) {
+            throw new InvalidNameException("ingredient name duplicated");
+        }
+    }
+
+    private boolean hasDuplicateName(List<String> names) {
+        HashSet<String> nonDuplicate = new HashSet<>(names);
+        return (names.size() != nonDuplicate.size());
+    }
+
+}

backend/src/main/java/net/pengcook/ingredient/service/IngredientSubstitutionService.java

@@ -0,0 +1,22 @@
+package net.pengcook.ingredient.service;
+
+import org.springframework.stereotype.Service;
+
+import net.pengcook.ingredient.domain.Ingredient;
+import net.pengcook.ingredient.domain.IngredientRecipe;
+import net.pengcook.ingredient.domain.IngredientSubstitution;
+import net.pengcook.ingredient.repository.IngredientSubstitutionRepository;
+
+import lombok.RequiredArgsConstructor;
+
+@Service
+@RequiredArgsConstructor
+public class IngredientSubstitutionService {
+
+    private final IngredientSubstitutionRepository ingredientSubstitutionRepository;
+
+    public void save(IngredientRecipe ingredientRecipe, Ingredient substitution) {
+        IngredientSubstitution ingredientSubstitution = new IngredientSubstitution(ingredientRecipe, substitution);
+        ingredientSubstitutionRepository.save(ingredientSubstitution);
+    }
+}

backend/src/test/java/net/pengcook/ingredient/dto/IngredientCreateRequestTest.java

@@ -0,0 +1,55 @@
+package net.pengcook.ingredient.dto;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Stream;
+import net.pengcook.ingredient.domain.Requirement;
+import net.pengcook.ingredient.exception.InvalidNameException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class IngredientCreateRequestTest {
+
+    static Stream<Arguments> substitutions() {
+        List<String> nullSubstitution = new ArrayList<>();
+        nullSubstitution.add(null);
+
+        return Stream.of(
+                Arguments.arguments(List.of("", "wheat")),
+                Arguments.arguments(List.of(" ", "wheat")),
+                Arguments.arguments(nullSubstitution)
+        );
+    }
+
+    @ParameterizedTest
+    @CsvSource(value = {
+            "''",
+            "' '",
+    })
+    @DisplayName("재료 이름에 공백 또는 null은 허용하지 않는다.")
+    void validateName(String name) {
+        assertThatThrownBy(() -> new IngredientCreateRequest(name, Requirement.ALTERNATIVE, List.of("wheat")))
+                .isInstanceOf(InvalidNameException.class);
+    }
+
+    @ParameterizedTest
+    @MethodSource("substitutions")
+    @DisplayName("ALTERNATIVE 상태일 때, 대체 재료 이름에 공백 또는 null은 허용하지 않는다.")
+    void validateSubstitutionName(List<String> substitutions) {
+        assertThatThrownBy(() -> new IngredientCreateRequest("rice", Requirement.ALTERNATIVE, substitutions))
+                .isInstanceOf(InvalidNameException.class);
+    }
+
+    @Test
+    @DisplayName("ALTERNATIVE 상태일 때, 대체 재료 리스트에 null은 허용하지 않는다.")
+    void validateSubstitutionIsNull() {
+        assertThatThrownBy(() -> new IngredientCreateRequest("rice", Requirement.ALTERNATIVE, null))
+                .isInstanceOf(InvalidNameException.class);
+    }
+}