start

src/main/java/com/example/hangry/Ingredient.java

@@ -1,9 +1,6 @@
 package com.example.hangry;
 
-import jakarta.persistence.Entity;
+import jakarta.persistence.*;
-import jakarta.persistence.GeneratedValue;
-import jakarta.persistence.GenerationType;
-import jakarta.persistence.Id;
 
 @Entity
 public class Ingredient {
@@ -14,11 +11,18 @@ public class Ingredient {
 
     private String name; // Name der Zutat
 
+    private boolean isGlobal; // Flag, ob die Zutat global ist (true) oder benutzerspezifisch (false)
+
+    @ManyToOne
+    @JoinColumn(name = "user_id")  // Verknüpft mit der 'User'-Tabelle
+    private User user;  // Hinzufügen einer 'user'-Beziehung
+
     public Ingredient() {
     }
 
-    public Ingredient(String name) {
+    public Ingredient(String name, boolean isGlobal) {
         this.name = name;
+        this.isGlobal = isGlobal;
     }
 
     // Getter und Setter
@@ -37,4 +41,20 @@ public class Ingredient {
     public void setName(String name) {
         this.name = name;
     }
+
+    public boolean isGlobal() {
+        return isGlobal;
+    }
+
+    public void setGlobal(boolean global) {
+        isGlobal = global;
+    }
+
+    public User getUser() {
+        return user;
+    }
+
+    public void setUser(User user) {
+        this.user = user;
+    }
 }

src/main/java/com/example/hangry/IngredientController.java

@@ -0,0 +1,85 @@
+package com.example.hangry;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Optional;
+
+@RestController
+@RequestMapping("/api/ingredients")
+public class IngredientController {
+
+    @Autowired
+    private IngredientService ingredientService;
+
+    // 1. Globale Zutaten abrufen
+    @GetMapping("/global")
+    public ResponseEntity<List<Ingredient>> getGlobalIngredients() {
+        List<Ingredient> ingredients = ingredientService.getGlobalIngredients();
+        return ResponseEntity.ok(ingredients);
+    }
+
+    // 2. Benutzerdefinierte Zutaten abrufen
+    @GetMapping("/user/{userId}")
+    public ResponseEntity<List<Ingredient>> getUserIngredients(@PathVariable Long userId) {
+        List<Ingredient> ingredients = ingredientService.getUserIngredients(userId);
+        return ResponseEntity.ok(ingredients);
+    }
+
+    // 3. Neue globale Zutat hinzufügen
+    @PostMapping("/global")
+    public ResponseEntity<Ingredient> addGlobalIngredient(@RequestBody Ingredient ingredient) {
+        Ingredient newIngredient = ingredientService.addGlobalIngredient(ingredient);
+        return ResponseEntity.status(HttpStatus.CREATED).body(newIngredient);
+    }
+
+    // 4. Benutzerdefinierte Zutat hinzufügen
+    @PostMapping("/user/{userId}")
+    public ResponseEntity<Ingredient> addUserIngredient(
+            @PathVariable Long userId,
+            @RequestBody Ingredient ingredient
+    ) {
+        Ingredient newIngredient = ingredientService.addUserIngredient(userId, ingredient);
+        return ResponseEntity.status(HttpStatus.CREATED).body(newIngredient);
+    }
+
+    // 5. Einzelne Zutat abrufen
+    @GetMapping("/{id}")
+    public ResponseEntity<Ingredient> getIngredientById(@PathVariable Long id) {
+        Optional<Ingredient> ingredient = ingredientService.getIngredientById(id);
+        if (ingredient.isPresent()) {
+            return ResponseEntity.ok(ingredient.get());
+        } else {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+    }
+
+    // 6. Zutat aktualisieren
+    @PutMapping("/{id}")
+    public ResponseEntity<Ingredient> updateIngredient(
+            @PathVariable Long id,
+            @RequestBody Ingredient updatedIngredient
+    ) {
+        Optional<Ingredient> ingredient = ingredientService.updateIngredient(id, updatedIngredient);
+        if (ingredient.isPresent()) {
+            return ResponseEntity.ok(ingredient.get());
+        } else {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+    }
+
+    // 7. Zutat löschen
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deleteIngredient(@PathVariable Long id) {
+        boolean deleted = ingredientService.deleteIngredient(id);
+        if (deleted) {
+            return ResponseEntity.status(HttpStatus.NO_CONTENT).build();
+        } else {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+    }
+}
+

src/main/java/com/example/hangry/IngredientRepository.java

@@ -0,0 +1,26 @@
+package com.example.hangry;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface IngredientRepository extends JpaRepository<Ingredient, Long> {
+
+    // 1. Alle globalen Zutaten abrufen
+    List<Ingredient> findByIsGlobal(boolean isGlobal);
+
+    // 2. Zutaten, die einem bestimmten Benutzer gehören, abrufen
+    List<Ingredient> findByUserId(Long userId);
+
+    // 3. Zutaten suchen, die global und/oder benutzerdefiniert nach Name passen
+    List<Ingredient> findByNameContainingIgnoreCase(String name);
+
+    // 4. Benutzerdefinierte Zutat für einen bestimmten Benutzer nach Namen abrufen
+    List<Ingredient> findByNameAndUserId(String name, Long userId);
+
+    // 5. Überprüfen, ob eine Zutat global existiert
+    boolean existsByNameAndIsGlobal(String name);
+}
+

src/main/java/com/example/hangry/IngredientService.java

@@ -0,0 +1,81 @@
+package com.example.hangry;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Optional;
+
+@Service
+public class IngredientService {
+
+    @Autowired
+    private IngredientRepository ingredientRepository;
+
+    @Autowired
+    private UserRepository userRepository;
+
+    // 1. Globale Zutaten abrufen
+    public List<Ingredient> getGlobalIngredients() {
+        return ingredientRepository.findByIsGlobal(true);
+    }
+
+    // 2. Benutzerdefinierte Zutaten abrufen
+    public List<Ingredient> getUserIngredients(Long userId) {
+        Optional<User> user = userRepository.findById(userId);
+        if (user.isPresent()) {
+            return ingredientRepository.findByUserId(userId);
+        } else {
+            throw new IllegalArgumentException("User not found with ID: " + userId);
+        }
+    }
+
+    // 3. Neue globale Zutat hinzufügen
+    public Ingredient addGlobalIngredient(Ingredient ingredient) {
+        ingredient.setGlobal(true); // Markiere die Zutat als global
+        return ingredientRepository.save(ingredient);
+    }
+
+    // 4. Benutzerdefinierte Zutat hinzufügen
+    public Ingredient addUserIngredient(Long userId, Ingredient ingredient) {
+        Optional<User> user = userRepository.findById(userId);
+        if (user.isPresent()) {
+            ingredient.setGlobal(false); // Markiere die Zutat als benutzerspezifisch
+            ingredient.setUser(user.get());
+            return ingredientRepository.save(ingredient);
+        } else {
+            throw new IllegalArgumentException("User not found with ID: " + userId);
+        }
+    }
+
+    // 5. Einzelne Zutat abrufen
+    public Optional<Ingredient> getIngredientById(Long id) {
+        return ingredientRepository.findById(id);
+    }
+
+    // 6. Zutat aktualisieren
+    public Optional<Ingredient> updateIngredient(Long id, Ingredient updatedIngredient) {
+        Optional<Ingredient> ingredient = ingredientRepository.findById(id);
+        if (ingredient.isPresent()) {
+            Ingredient existingIngredient = ingredient.get();
+            existingIngredient.setName(updatedIngredient.getName());
+            existingIngredient.setUnit(updatedIngredient.getUnit());
+            return Optional.of(ingredientRepository.save(existingIngredient));
+        } else {
+            return Optional.empty();
+        }
+    }
+
+    // 7. Zutat löschen
+    public boolean deleteIngredient(Long id) {
+        Optional<Ingredient> ingredient = ingredientRepository.findById(id);
+        if (ingredient.isPresent()) {
+            ingredientRepository.deleteById(id);
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+
+

src/main/java/com/example/hangry/User.java

@@ -0,0 +1,105 @@
+package com.example.hangry;
+
+import jakarta.persistence.*;
+import java.util.ArrayList;
+import java.util.List;
+
+@Entity
+public class User {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(unique = true, nullable = false)
+    private String username;
+
+    @Column(nullable = false)
+    private String password;  // Hier solltest du sicherstellen, dass das Passwort verschlüsselt wird
+
+    @Column(unique = true, nullable = false)
+    private String email;
+
+    private String role; // Für Rollen wie "ADMIN", "USER", etc.
+
+    // Many-to-Many Beziehung zu Ingredients
+    @ManyToMany
+    @JoinTable(
+            name = "user_ingredients",
+            joinColumns = @JoinColumn(name = "user_id"),
+            inverseJoinColumns = @JoinColumn(name = "ingredient_id")
+    )
+    private List<Ingredient> ingredients = new ArrayList<>();
+
+    // No-Args-Konstruktor (wichtig für JPA)
+    public User() {
+    }
+
+    // All-Args-Konstruktor
+    public User(Long id, String username, String password, String email, String role) {
+        this.id = id;
+        this.username = username;
+        this.password = password;
+        this.email = email;
+        this.role = role;
+    }
+
+    // Getter und Setter
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    public String getRole() {
+        return role;
+    }
+
+    public void setRole(String role) {
+        this.role = role;
+    }
+
+    public List<Ingredient> getIngredients() {
+        return ingredients;
+    }
+
+    public void setIngredients(List<Ingredient> ingredients) {
+        this.ingredients = ingredients;
+    }
+
+    // Methode, um eine Zutat zu einem User hinzuzufügen
+    public void addIngredient(Ingredient ingredient) {
+        this.ingredients.add(ingredient);
+    }
+
+    // Methode, um eine Zutat aus der Liste zu entfernen
+    public void removeIngredient(Ingredient ingredient) {
+        this.ingredients.remove(ingredient);
+    }
+}

src/main/java/com/example/hangry/UserController.java

@@ -0,0 +1,33 @@
+package com.example.hangry;
+
+import org.springframework.web.bind.annotation.*;
+import java.util.List;
+
+@RestController
+@RequestMapping("/users")
+public class UserController {
+
+    private final UserService userService;
+
+    public UserController(UserService userService) {
+        this.userService = userService;
+    }
+
+    // Endpunkt: Benutzer erstellen
+    @PostMapping
+    public User createUser(@RequestBody User user) {
+        return userService.createUser(user);
+    }
+
+    // Endpunkt: Benutzer nach Benutzername abrufen
+    @GetMapping("/username/{username}")
+    public User getUserByUsername(@PathVariable String username) {
+        return userService.getUserByUsername(username);
+    }
+
+    // Endpunkt: Benutzer nach E-Mail abrufen
+    @GetMapping("/email/{email}")
+    public User getUserByEmail(@PathVariable String email) {
+        return userService.getUserByEmail(email);
+    }
+}

src/main/java/com/example/hangry/UserRepository.java

@@ -0,0 +1,15 @@
+    package com.example.hangry;
+
+    import org.springframework.data.jpa.repository.JpaRepository;
+    import org.springframework.stereotype.Repository;
+
+    @Repository
+    public interface UserRepository extends JpaRepository<User, Long> {
+
+        // Benutzerdefinierte Abfrage: Benutzer nach Benutzernamen finden
+        User findByUsername(String username);
+
+        // Benutzerdefinierte Abfrage: Benutzer nach E-Mail finden
+        User findByEmail(String email);
+    }
+

src/main/java/com/example/hangry/UserService.java

@@ -0,0 +1,29 @@
+package com.example.hangry;
+
+import org.springframework.stereotype.Service;
+
+@Service
+public class UserService {
+
+    private final UserRepository userRepository;
+
+    // Dependency Injection (Spring kümmert sich darum)
+    public UserService(UserRepository userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    // Einen neuen Benutzer erstellen
+    public User createUser(User user) {
+        return userRepository.save(user);
+    }
+
+    // Benutzer anhand des Benutzernamens suchen
+    public User getUserByUsername(String username) {
+        return userRepository.findByUsername(username);
+    }
+
+    // Benutzer anhand der E-Mail suchen
+    public User getUserByEmail(String email) {
+        return userRepository.findByEmail(email);
+    }
+}