From 99aaa482cd3b8c9548286a05690f74f7a129066e Mon Sep 17 00:00:00 2001 From: PaulK Date: Tue, 28 Jan 2025 13:24:57 +0100 Subject: [PATCH] start --- .../java/com/example/hangry/Ingredient.java | 30 ++++- .../example/hangry/IngredientController.java | 85 ++++++++++++++ .../example/hangry/IngredientRepository.java | 26 +++++ .../com/example/hangry/IngredientService.java | 81 ++++++++++++++ src/main/java/com/example/hangry/User.java | 105 ++++++++++++++++++ .../com/example/hangry/UserController.java | 33 ++++++ .../com/example/hangry/UserRepository.java | 15 +++ .../java/com/example/hangry/UserService.java | 29 +++++ 8 files changed, 399 insertions(+), 5 deletions(-) create mode 100644 src/main/java/com/example/hangry/IngredientController.java create mode 100644 src/main/java/com/example/hangry/IngredientRepository.java create mode 100644 src/main/java/com/example/hangry/IngredientService.java create mode 100644 src/main/java/com/example/hangry/User.java create mode 100644 src/main/java/com/example/hangry/UserController.java create mode 100644 src/main/java/com/example/hangry/UserRepository.java create mode 100644 src/main/java/com/example/hangry/UserService.java diff --git a/src/main/java/com/example/hangry/Ingredient.java b/src/main/java/com/example/hangry/Ingredient.java index b1ce6eb..2cb9ecb 100644 --- a/src/main/java/com/example/hangry/Ingredient.java +++ b/src/main/java/com/example/hangry/Ingredient.java @@ -1,9 +1,6 @@ package com.example.hangry; -import jakarta.persistence.Entity; -import jakarta.persistence.GeneratedValue; -import jakarta.persistence.GenerationType; -import jakarta.persistence.Id; +import jakarta.persistence.*; @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; + } } diff --git a/src/main/java/com/example/hangry/IngredientController.java b/src/main/java/com/example/hangry/IngredientController.java new file mode 100644 index 0000000..22422c7 --- /dev/null +++ b/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> getGlobalIngredients() { + List ingredients = ingredientService.getGlobalIngredients(); + return ResponseEntity.ok(ingredients); + } + + // 2. Benutzerdefinierte Zutaten abrufen + @GetMapping("/user/{userId}") + public ResponseEntity> getUserIngredients(@PathVariable Long userId) { + List ingredients = ingredientService.getUserIngredients(userId); + return ResponseEntity.ok(ingredients); + } + + // 3. Neue globale Zutat hinzufügen + @PostMapping("/global") + public ResponseEntity 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 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 getIngredientById(@PathVariable Long id) { + Optional 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 updateIngredient( + @PathVariable Long id, + @RequestBody Ingredient updatedIngredient + ) { + Optional 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 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(); + } + } +} + diff --git a/src/main/java/com/example/hangry/IngredientRepository.java b/src/main/java/com/example/hangry/IngredientRepository.java new file mode 100644 index 0000000..fa90c42 --- /dev/null +++ b/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 { + + // 1. Alle globalen Zutaten abrufen + List findByIsGlobal(boolean isGlobal); + + // 2. Zutaten, die einem bestimmten Benutzer gehören, abrufen + List findByUserId(Long userId); + + // 3. Zutaten suchen, die global und/oder benutzerdefiniert nach Name passen + List findByNameContainingIgnoreCase(String name); + + // 4. Benutzerdefinierte Zutat für einen bestimmten Benutzer nach Namen abrufen + List findByNameAndUserId(String name, Long userId); + + // 5. Überprüfen, ob eine Zutat global existiert + boolean existsByNameAndIsGlobal(String name); +} + diff --git a/src/main/java/com/example/hangry/IngredientService.java b/src/main/java/com/example/hangry/IngredientService.java new file mode 100644 index 0000000..20f6614 --- /dev/null +++ b/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 getGlobalIngredients() { + return ingredientRepository.findByIsGlobal(true); + } + + // 2. Benutzerdefinierte Zutaten abrufen + public List getUserIngredients(Long userId) { + Optional 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 = 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 getIngredientById(Long id) { + return ingredientRepository.findById(id); + } + + // 6. Zutat aktualisieren + public Optional updateIngredient(Long id, Ingredient updatedIngredient) { + Optional 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 = ingredientRepository.findById(id); + if (ingredient.isPresent()) { + ingredientRepository.deleteById(id); + return true; + } else { + return false; + } + } +} + + diff --git a/src/main/java/com/example/hangry/User.java b/src/main/java/com/example/hangry/User.java new file mode 100644 index 0000000..3008965 --- /dev/null +++ b/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 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 getIngredients() { + return ingredients; + } + + public void setIngredients(List 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); + } +} diff --git a/src/main/java/com/example/hangry/UserController.java b/src/main/java/com/example/hangry/UserController.java new file mode 100644 index 0000000..5402b4a --- /dev/null +++ b/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); + } +} diff --git a/src/main/java/com/example/hangry/UserRepository.java b/src/main/java/com/example/hangry/UserRepository.java new file mode 100644 index 0000000..94c72ac --- /dev/null +++ b/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 { + + // Benutzerdefinierte Abfrage: Benutzer nach Benutzernamen finden + User findByUsername(String username); + + // Benutzerdefinierte Abfrage: Benutzer nach E-Mail finden + User findByEmail(String email); + } + diff --git a/src/main/java/com/example/hangry/UserService.java b/src/main/java/com/example/hangry/UserService.java new file mode 100644 index 0000000..f81b6c1 --- /dev/null +++ b/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); + } +}