Base ingredient

src/main/java/CaffeineCoder/recipic/domain/brand/api/BrandController.java

@@ -1,14 +1,12 @@
 package CaffeineCoder.recipic.domain.brand.api;
 
-
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
-import java.util.LinkedHashMap;
-
 @RestController
 @RequestMapping("/api/brand")
 public class BrandController {
@@ -19,51 +17,68 @@ public BrandController(BrandService brandService) {
         this.brandService = brandService;
     }
 
-    // /ingredients 엔드포인트를 GET 방식으로 변경
-    @GetMapping("/ingredients")
-    public ResponseEntity<Map<String, Object>> getIngredientsByBrandName(@RequestParam("brandName") String brandName) {
-        // @RequestBody 대신 @RequestParam을 사용하여 쿼리 매개변수로 brandName을 받음
-        List<Map<String, Object>> ingredients = brandService.getIngredientsByBrandName(brandName);
+    // BaseIngredient 추가 API (brandId 사용)
+    @PostMapping("/add-baseingredient")
+    public ResponseEntity<Map<String, Object>> addBaseIngredientToBrand(@RequestBody Map<String, Object> request) {
+        Integer brandId = (Integer) request.get("brandId");
+        String ingredientName = (String) request.get("ingredientName");
+        String size = (String) request.get("size");
+
+        boolean success = brandService.addBaseIngredientToBrand(brandId, ingredientName, size);
 
         Map<String, Object> response = new LinkedHashMap<>();
-        response.put("isSuccess", true);
-        response.put("response", ingredients);
+        response.put("isSuccess", success);
+        response.put("message", success ? "Base Ingredient added successfully" : "Failed to add Base Ingredient");
 
         return ResponseEntity.ok(response);
     }
 
+
+    // Ingredient 추가 API (BaseIngredient에 연결)
     @PostMapping("/add-ingredient")
-    public ResponseEntity<Map<String, Object>> addIngredientToBrand(@RequestBody Map<String, Object> request) {
-        String brandName = (String) request.get("brandName");
+    public ResponseEntity<Map<String, Object>> addIngredient(@RequestBody Map<String, Object> request) {
+        Integer baseIngredientId = (Integer) request.get("baseIngredientId");  // BaseIngredient의 ID를 받음
         String ingredientName = (String) request.get("ingredientName");
-
-        // quantity는 클라이언트에서 Long 타입으로 보내야함
-        Long quantity = request.get("quantity") instanceof Integer
-                ? Long.valueOf((Integer) request.get("quantity"))
-                : (Long) request.get("quantity");
-
+        Long quantity = Long.parseLong(request.get("quantity").toString());
         String unit = (String) request.get("unit");
         Integer cost = (Integer) request.get("cost");
+        Double calorie = Double.parseDouble(request.get("calorie").toString());
 
-        // calorie는 Double로 변환
-        Double calorie = request.get("calorie") instanceof Integer
-                ? Double.valueOf((Integer) request.get("calorie"))
-                : (Double) request.get("calorie");
-
-        boolean success = brandService.addIngredientToBrand(brandName, ingredientName, quantity, unit, cost, calorie);
+        // baseIngredientId를 추가해서 호출
+        boolean success = brandService.addIngredient(baseIngredientId, ingredientName, quantity, unit, cost, calorie);
 
         Map<String, Object> response = new LinkedHashMap<>();
         response.put("isSuccess", success);
-        if (success) {
-            response.put("message", "Ingredient added successfully.");
-        } else {
-            response.put("message", "Failed to add ingredient.");
-        }
+        response.put("message", success ? "Ingredient added successfully" : "Failed to add Ingredient");
+
+        return ResponseEntity.ok(response);
+    }
+
+    // 브랜드 이름으로 BaseIngredient 조회 API
+    @GetMapping("/baseingredients")
+    public ResponseEntity<Map<String, Object>> getBaseIngredientsByBrandName(@RequestParam("brandName") String brandName) {
+        List<Map<String, Object>> baseIngredients = brandService.getBaseIngredientsByBrandName(brandName);
+
+        Map<String, Object> response = new LinkedHashMap<>();
+        response.put("isSuccess", true);
+        response.put("response", baseIngredients);
+
+        return ResponseEntity.ok(response);
+    }
+
+    // 특정 BaseIngredient에 매핑된 Ingredient 조회 API
+    @GetMapping("/baseingredient/{baseIngredientId}/ingredients")
+    public ResponseEntity<Map<String, Object>> getIngredientsByBaseIngredientId(@PathVariable Integer baseIngredientId) {
+        List<Map<String, Object>> ingredients = brandService.getIngredientsByBaseIngredientId(baseIngredientId);
+
+        Map<String, Object> response = new LinkedHashMap<>();
+        response.put("isSuccess", true);
+        response.put("response", ingredients);
 
         return ResponseEntity.ok(response);
     }
 
-    //모든 브랜드 가져오기
+    // 모든 브랜드 가져오기
     @GetMapping("/list")
     public ResponseEntity<Map<String, Object>> getAllBrands() {
         List<Map<String, Object>> brands = brandService.getAllBrands();

src/main/java/CaffeineCoder/recipic/domain/brand/api/BrandService.java

@@ -1,13 +1,7 @@
 package CaffeineCoder.recipic.domain.brand.api;
 
-import CaffeineCoder.recipic.domain.brand.dto.IngredientDTO;
-import CaffeineCoder.recipic.domain.brand.domain.Brand;
-import CaffeineCoder.recipic.domain.brand.domain.BrandIngredient;
-import CaffeineCoder.recipic.domain.brand.domain.Ingredient;
-import CaffeineCoder.recipic.domain.brand.repository.BrandIngredientRepository;
-import CaffeineCoder.recipic.domain.brand.repository.BrandRepository;
-import CaffeineCoder.recipic.domain.brand.repository.IngredientRepository;
-import jakarta.persistence.criteria.CriteriaBuilder;
+import CaffeineCoder.recipic.domain.brand.domain.*;
+import CaffeineCoder.recipic.domain.brand.repository.*;
 import org.springframework.stereotype.Service;
 
 import java.util.LinkedHashMap;
@@ -20,69 +14,89 @@
 public class BrandService {
 
     private final BrandRepository brandRepository;
-    private final BrandIngredientRepository brandIngredientRepository;
+    private final BaseIngredientRepository baseIngredientRepository;
     private final IngredientRepository ingredientRepository;
+    private final BaseIngredientSizeRepository baseIngredientSizeRepository;
 
-    public BrandService(BrandRepository brandRepository, BrandIngredientRepository brandIngredientRepository, IngredientRepository ingredientRepository) {
+    public BrandService(BrandRepository brandRepository, BaseIngredientRepository baseIngredientRepository,
+                        IngredientRepository ingredientRepository, BaseIngredientSizeRepository baseIngredientSizeRepository) {
         this.brandRepository = brandRepository;
-        this.brandIngredientRepository = brandIngredientRepository;
+        this.baseIngredientRepository = baseIngredientRepository;
         this.ingredientRepository = ingredientRepository;
+        this.baseIngredientSizeRepository = baseIngredientSizeRepository;
     }
 
-    public List<Map<String, Object>> getIngredientsByBrandName(String brandName) {
-        Brand brand = brandRepository.findByBrandName(brandName)
-                .orElseThrow(() -> new RuntimeException("Brand not found"));
+    // BaseIngredient 추가 (brandId 사용)
+    public boolean addBaseIngredientToBrand(Integer brandId, String ingredientName, String size) {
+        Brand brand = brandRepository.findById(brandId)
+                .orElseThrow(() -> new RuntimeException("Brand not found with ID: " + brandId));
 
-        return brandIngredientRepository.findByBrand(brand)
-                .stream()
-                .map(brandIngredient -> {
-                    Ingredient ingredient = brandIngredient.getIngredient();
-
-                    IngredientDTO dto = new IngredientDTO.Builder()
-                            .ingredientId(ingredient.getIngredientId())
-                            .name(ingredient.getIngredientName())
-                            .quantity(ingredient.getQuantity())
-                            .unit(ingredient.getUnit())
-                            .cost(ingredient.getCost())
-                            .calorie(ingredient.getCalorie())
-                            .build();
-
-                    return dto.toMap();
-                })
-                .collect(Collectors.toList());
-    }
+        // BaseIngredient 생성 및 저장
+        BaseIngredient baseIngredient = new BaseIngredient(ingredientName, brand);
+        baseIngredientRepository.save(baseIngredient);
 
-    public boolean addIngredientToBrand(String brandName, String ingredientName, Long quantity, String unit, Integer cost, Double calorie) {
+        // BaseIngredientSize도 생성 및 저장
+        BaseIngredientSize baseIngredientSize = new BaseIngredientSize(size, baseIngredient);
+        baseIngredientSizeRepository.save(baseIngredientSize);
 
-        Optional<Brand> optionalBrand = brandRepository.findByBrandName(brandName);
-        if (optionalBrand.isEmpty()) {
-            return false;
-        }
-        Brand brand = optionalBrand.get();
+        return true;
+    }
 
-        // 새로운 Ingredient 객체 생성
+    // Ingredient 추가 (BaseIngredient와 연결)
+    public boolean addIngredient(Integer baseIngredientId, String ingredientName, Long quantity, String unit, Integer cost, Double calorie) {
+        BaseIngredient baseIngredient = baseIngredientRepository.findById(baseIngredientId)
+                .orElseThrow(() -> new RuntimeException("BaseIngredient not found with ID: " + baseIngredientId));
 
         Ingredient ingredient = Ingredient.builder()
                 .ingredientName(ingredientName)
                 .quantity(quantity)
                 .unit(unit)
                 .cost(cost)
                 .calorie(calorie)
+                .baseIngredient(baseIngredient)
                 .build();
 
-        // Ingredient 저장
         ingredientRepository.save(ingredient);
+        return true;
+    }
 
-        // BrandIngredient 객체 생성
-        BrandIngredient brandIngredient = new BrandIngredient();
-        brandIngredient.setIngredient(ingredient);
-        brandIngredient.setBrand(brand);
-        brandIngredientRepository.save(brandIngredient);
+    // 브랜드 이름으로 BaseIngredient 가져오기
+    public List<Map<String, Object>> getBaseIngredientsByBrandName(String brandName) {
+        Brand brand = brandRepository.findByBrandName(brandName)
+                .orElseThrow(() -> new RuntimeException("Brand not found"));
 
-        return true;
+        return baseIngredientRepository.findByBrand(brand)
+                .stream()
+                .map(baseIngredient -> {
+                    Map<String, Object> baseIngredientMap = new LinkedHashMap<>();
+                    baseIngredientMap.put("ingredientId", baseIngredient.getBaseIngredientId());
+                    baseIngredientMap.put("name", baseIngredient.getIngredientName());
+                    return baseIngredientMap;
+                })
+                .collect(Collectors.toList());
     }
 
-    //모든 브랜드 가져오기
+    // BaseIngredient에 매핑된 Ingredient 조회
+    public List<Map<String, Object>> getIngredientsByBaseIngredientId(Integer baseIngredientId) {
+        BaseIngredient baseIngredient = baseIngredientRepository.findById(baseIngredientId)
+                .orElseThrow(() -> new RuntimeException("BaseIngredient not found with ID: " + baseIngredientId));
+
+        // BaseIngredient에 매핑된 Ingredient들을 가져와 Map으로 변환
+        return baseIngredient.getIngredients().stream()
+                .map(ingredient -> {
+                    Map<String, Object> ingredientMap = new LinkedHashMap<>();
+                    ingredientMap.put("ingredientId", ingredient.getIngredientId());
+                    ingredientMap.put("name", ingredient.getIngredientName());
+                    ingredientMap.put("quantity", ingredient.getQuantity());
+                    ingredientMap.put("unit", ingredient.getUnit());
+                    ingredientMap.put("cost", ingredient.getCost());
+                    ingredientMap.put("calorie", ingredient.getCalorie());
+                    return ingredientMap;
+                })
+                .collect(Collectors.toList());
+    }
+
+    // 모든 브랜드 가져오기
     public List<Map<String, Object>> getAllBrands() {
         return brandRepository.findAll().stream()
                 .map(brand -> {
@@ -93,8 +107,4 @@ public List<Map<String, Object>> getAllBrands() {
                 })
                 .collect(Collectors.toList());
     }
-
-    public String getBrandNameByBrandId(Integer brandId) {
-        return brandRepository.findBrandNameByBrandId(brandId);
-    }
 }

src/main/java/CaffeineCoder/recipic/domain/brand/domain/BaseIngredient.java

@@ -0,0 +1,37 @@
+package CaffeineCoder.recipic.domain.brand.domain;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@Entity
+@Getter
+@NoArgsConstructor
+public class BaseIngredient {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "baseingredient_id")
+    private Integer baseIngredientId;
+
+    @Column(name = "ingredient_name", nullable = false)
+    private String ingredientName;
+
+    @OneToMany(mappedBy = "baseIngredient", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<BaseIngredientSize> baseIngredientSizes;
+
+    @ManyToOne
+    @JoinColumn(name = "brand_id", nullable = false)
+    private Brand brand;
+
+    @OneToMany(mappedBy = "baseIngredient", cascade = CascadeType.ALL, orphanRemoval = true)
+    private List<Ingredient> ingredients;  // Ingredient와 연결
+
+    public BaseIngredient(String ingredientName, Brand brand) {
+        this.ingredientName = ingredientName;
+        this.brand = brand;
+    }
+}
+

src/main/java/CaffeineCoder/recipic/domain/brand/domain/BaseIngredientSize.java

@@ -0,0 +1,30 @@
+package CaffeineCoder.recipic.domain.brand.domain;
+
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Getter
+@NoArgsConstructor
+public class BaseIngredientSize {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "baseingredient_size_id")
+    private Integer baseIngredientSizeId;
+
+    @Column(name = "size", nullable = false)
+    private String size;
+
+    @ManyToOne
+    @JoinColumn(name = "baseingredient_id", nullable = false)
+    private BaseIngredient baseIngredient;
+
+    public BaseIngredientSize(String size, BaseIngredient baseIngredient) {
+        this.size = size;
+        this.baseIngredient = baseIngredient;
+    }
+}
+
+

src/main/java/CaffeineCoder/recipic/domain/brand/domain/Brand.java

@@ -16,13 +16,14 @@ public class Brand {
     @Column(name = "brand_id")
     private Integer brandId;
 
-    @Column(name = "brand_name", nullable = false)
+    @Column(name = "brand_name", nullable = false, unique = true)
     private String brandName;
 
     @OneToMany(mappedBy = "brand", cascade = CascadeType.ALL, orphanRemoval = true)
-    private List<BrandIngredient> brandIngredients;
+    private List<BaseIngredient> baseIngredients;
 
-    public Integer getBrandId() {
-        return brandId;
+    public Brand(Integer brandId, String brandName) {
+        this.brandId = brandId;
+        this.brandName = brandName;
     }
 }

src/main/java/CaffeineCoder/recipic/domain/brand/domain/BrandIngredient.java

@@ -18,21 +18,13 @@ public class BrandIngredient {
     private Brand brand;
 
     @ManyToOne
-    @MapsId("ingredientId")
-    @JoinColumn(name = "ingredient_id")
-    private Ingredient ingredient;
+    @MapsId("baseIngredientId")
+    @JoinColumn(name = "baseingredient_id")
+    private BaseIngredient baseIngredient;
 
-    public void setIngredient(Ingredient ingredient) {
-        this.ingredient = ingredient;
-        if (this.brand != null) {
-            this.id = new BrandIngredientId(this.brand.getBrandId(), ingredient.getIngredientId());
-        }
-    }
-
-    public void setBrand(Brand brand) {
+    public BrandIngredient(Brand brand, BaseIngredient baseIngredient) {
         this.brand = brand;
-        if (this.ingredient != null) {
-            this.id = new BrandIngredientId(brand.getBrandId(), this.ingredient.getIngredientId());
-        }
+        this.baseIngredient = baseIngredient;
+        this.id = new BrandIngredientId(brand.getBrandId(), baseIngredient.getBaseIngredientId());
     }
 }