Revert "Base ingredient (#93)"

This reverts commit d6c450f.

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

@@ -1,12 +1,14 @@
 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 {
@@ -17,68 +19,51 @@ public BrandController(BrandService brandService) {
         this.brandService = brandService;
     }
 
-    // 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);
+    // /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);
 
         Map<String, Object> response = new LinkedHashMap<>();
-        response.put("isSuccess", success);
-        response.put("message", success ? "Base Ingredient added successfully" : "Failed to add Base Ingredient");
+        response.put("isSuccess", true);
+        response.put("response", ingredients);
 
         return ResponseEntity.ok(response);
     }
 
-
-    // Ingredient 추가 API (BaseIngredient에 연결)
     @PostMapping("/add-ingredient")
-    public ResponseEntity<Map<String, Object>> addIngredient(@RequestBody Map<String, Object> request) {
-        Integer baseIngredientId = (Integer) request.get("baseIngredientId");  // BaseIngredient의 ID를 받음
+    public ResponseEntity<Map<String, Object>> addIngredientToBrand(@RequestBody Map<String, Object> request) {
+        String brandName = (String) request.get("brandName");
         String ingredientName = (String) request.get("ingredientName");
-        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());
-
-        // baseIngredientId를 추가해서 호출
-        boolean success = brandService.addIngredient(baseIngredientId, ingredientName, quantity, unit, cost, calorie);
-
-        Map<String, Object> response = new LinkedHashMap<>();
-        response.put("isSuccess", success);
-        response.put("message", success ? "Ingredient added successfully" : "Failed to add Ingredient");
 
-        return ResponseEntity.ok(response);
-    }
+        // quantity는 클라이언트에서 Long 타입으로 보내야함
+        Long quantity = request.get("quantity") instanceof Integer
+                ? Long.valueOf((Integer) request.get("quantity"))
+                : (Long) request.get("quantity");
 
-    // 브랜드 이름으로 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);
+        String unit = (String) request.get("unit");
+        Integer cost = (Integer) request.get("cost");
 
-        return ResponseEntity.ok(response);
-    }
+        // calorie는 Double로 변환
+        Double calorie = request.get("calorie") instanceof Integer
+                ? Double.valueOf((Integer) request.get("calorie"))
+                : (Double) request.get("calorie");
 
-    // 특정 BaseIngredient에 매핑된 Ingredient 조회 API
-    @GetMapping("/baseingredient/{baseIngredientId}/ingredients")
-    public ResponseEntity<Map<String, Object>> getIngredientsByBaseIngredientId(@PathVariable Integer baseIngredientId) {
-        List<Map<String, Object>> ingredients = brandService.getIngredientsByBaseIngredientId(baseIngredientId);
+        boolean success = brandService.addIngredientToBrand(brandName, ingredientName, quantity, unit, cost, calorie);
 
         Map<String, Object> response = new LinkedHashMap<>();
-        response.put("isSuccess", true);
-        response.put("response", ingredients);
+        response.put("isSuccess", success);
+        if (success) {
+            response.put("message", "Ingredient added successfully.");
+        } else {
+            response.put("message", "Failed to add ingredient.");
+        }
 
         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,7 +1,13 @@
 package CaffeineCoder.recipic.domain.brand.api;
 
-import CaffeineCoder.recipic.domain.brand.domain.*;
-import CaffeineCoder.recipic.domain.brand.repository.*;
+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 org.springframework.stereotype.Service;
 
 import java.util.LinkedHashMap;
@@ -14,89 +20,69 @@
 public class BrandService {
 
     private final BrandRepository brandRepository;
-    private final BaseIngredientRepository baseIngredientRepository;
+    private final BrandIngredientRepository brandIngredientRepository;
     private final IngredientRepository ingredientRepository;
-    private final BaseIngredientSizeRepository baseIngredientSizeRepository;
 
-    public BrandService(BrandRepository brandRepository, BaseIngredientRepository baseIngredientRepository,
-                        IngredientRepository ingredientRepository, BaseIngredientSizeRepository baseIngredientSizeRepository) {
+    public BrandService(BrandRepository brandRepository, BrandIngredientRepository brandIngredientRepository, IngredientRepository ingredientRepository) {
         this.brandRepository = brandRepository;
-        this.baseIngredientRepository = baseIngredientRepository;
+        this.brandIngredientRepository = brandIngredientRepository;
         this.ingredientRepository = ingredientRepository;
-        this.baseIngredientSizeRepository = baseIngredientSizeRepository;
     }
 
-    // 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));
+    public List<Map<String, Object>> getIngredientsByBrandName(String brandName) {
+        Brand brand = brandRepository.findByBrandName(brandName)
+                .orElseThrow(() -> new RuntimeException("Brand not found"));
 
-        // BaseIngredient 생성 및 저장
-        BaseIngredient baseIngredient = new BaseIngredient(ingredientName, brand);
-        baseIngredientRepository.save(baseIngredient);
+        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());
+    }
 
-        // BaseIngredientSize도 생성 및 저장
-        BaseIngredientSize baseIngredientSize = new BaseIngredientSize(size, baseIngredient);
-        baseIngredientSizeRepository.save(baseIngredientSize);
+    public boolean addIngredientToBrand(String brandName, String ingredientName, Long quantity, String unit, Integer cost, Double calorie) {
 
-        return true;
-    }
+        Optional<Brand> optionalBrand = brandRepository.findByBrandName(brandName);
+        if (optionalBrand.isEmpty()) {
+            return false;
+        }
+        Brand brand = optionalBrand.get();
 
-    // 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 = Ingredient.builder()
                 .ingredientName(ingredientName)
                 .quantity(quantity)
                 .unit(unit)
                 .cost(cost)
                 .calorie(calorie)
-                .baseIngredient(baseIngredient)
                 .build();
 
+        // Ingredient 저장
         ingredientRepository.save(ingredient);
-        return true;
-    }
 
-    // 브랜드 이름으로 BaseIngredient 가져오기
-    public List<Map<String, Object>> getBaseIngredientsByBrandName(String brandName) {
-        Brand brand = brandRepository.findByBrandName(brandName)
-                .orElseThrow(() -> new RuntimeException("Brand not found"));
-
-        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());
-    }
+        // BrandIngredient 객체 생성
+        BrandIngredient brandIngredient = new BrandIngredient();
+        brandIngredient.setIngredient(ingredient);
+        brandIngredient.setBrand(brand);
+        brandIngredientRepository.save(brandIngredient);
 
-    // 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());
+        return true;
     }
 
-    // 모든 브랜드 가져오기
+    //모든 브랜드 가져오기
     public List<Map<String, Object>> getAllBrands() {
         return brandRepository.findAll().stream()
                 .map(brand -> {
@@ -107,4 +93,8 @@ 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/Brand.java

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

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

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