Merge pull request 'chore: Update branch' (#4) from Maradona/Backend:restfull into restfull

Reviewed-on: #4

src/main/java/com/maradona/backend/controllers/api/EmployeeController.java

@@ -21,6 +21,7 @@ import com.maradona.backend.services.EmployeeService;
  * 
  * Endpoints:
  * - GET /api/employee
+ * - GET /api/employee/{eid}
  * - GET /api/employee/all
  * - GET /api/employee/from-skill
  * - GET /api/employee/skill/all
@@ -40,15 +41,30 @@ public class EmployeeController {
   Long user = Long.valueOf(1);
 
   /**
-   * Returns a specific employee from the database.
+   * Returns the employee profile of the currently logged in user.
    * 
-   * @param id The ID of the requested employee.
+   * @return The employee profile of the currently logged in user.
-   * @return The employee with the requested ID.
    * @see com.maradona.backend.entities.Employee
    */
   @GetMapping({ "/", "" })
-  public ResponseEntity<Employee> get(@RequestParam Long id) {
+  public ResponseEntity<Employee> get() {
-    return employeeService.getEmployeeById(id)
+    var employee = employeeService.getEmployeeByEid(user);
+    return employee
+        .map(ResponseEntity::ok)
+        .orElse(ResponseEntity.notFound().build());
+  }
+
+  /**
+   * Returns a specific employee from the database.
+   * 
+   * @param eid The ID of the requested employee.
+   * @return The employee with the requested ID.
+   * @see com.maradona.backend.entities.Employee
+   */
+  @GetMapping("/{eid}")
+  public ResponseEntity<Employee> get(@RequestParam Long eid) {
+    var employee = employeeService.getEmployeeByEid(eid);
+    return employee
         .map(ResponseEntity::ok)
         .orElse(ResponseEntity.notFound().build());
   }
@@ -67,15 +83,15 @@ public class EmployeeController {
   /**
    * Returns a list of employees for a given secondary skill and level.
    * 
-   * @param skillId ID of the secondary skill
+   * @param ssid  ID of the secondary skill
-   * @param level   Level of the secondary skill
+   * @param level Level of the secondary skill
    * @return list of employees
    * @see com.maradona.backend.entities.Employee
    * @see com.maradona.backend.entities.SecondarySkill
    */
   @GetMapping("/from-skill")
-  public ResponseEntity<Iterable<Employee>> getFromSkill(@RequestParam Long skillId, @RequestParam Integer level) {
+  public ResponseEntity<Iterable<Employee>> getFromSkill(@RequestParam Long ssid, @RequestParam Integer level) {
-    return ResponseEntity.ok(employeeService.getEmployeesBySecondarySkill(skillId, level));
+    return ResponseEntity.ok(employeeService.getEmployeesBySecondarySkill(ssid, level));
   }
 
   /**
@@ -96,30 +112,30 @@ public class EmployeeController {
   /**
    * Updates the level of a secondary skill in the user profile.
    * 
-   * @param skillId ID of the secondary skill
+   * @param ssid  ID of the secondary skill
-   * @param level   Level of the secondary skill
+   * @param level Level of the secondary skill
    * @return HTTP status indicating the outcome of the operation
    * @see com.maradona.backend.entities.Employee
    * @see com.maradona.backend.entities.SecondarySkill
    * @see com.maradona.backend.entities.EmployeeSecondarySkill
    */
   @PutMapping("/skill/level")
-  public ResponseEntity<Void> putSkillLevel(@RequestParam Long skillId, @RequestParam Integer level) {
+  public ResponseEntity<Void> putSkillLevel(@RequestParam Long ssid, @RequestParam Integer level) {
-    employeeService.updateSecondarySkillLevel(user, skillId, level);
+    employeeService.updateSecondarySkillLevel(user, ssid, level);
     return ResponseEntity.ok().build();
   }
 
   /**
    * Removes a secondary skill from the user profile.
    * 
-   * @param id The ID of the secondary skill to be removed
+   * @param ssid The ID of the secondary skill to be removed
    * @return HTTP status indicating the outcome of the operation
    * @see com.maradona.backend.entities.Employee
    * @see com.maradona.backend.entities.SecondarySkill
    */
   @DeleteMapping("/skill")
-  public ResponseEntity<Void> delete(@RequestParam Long id) {
+  public ResponseEntity<Void> delete(@RequestParam Long ssid) {
-    employeeService.deleteSecondarySkillFromEmployee(user, id);
+    employeeService.deleteSecondarySkillFromEmployee(user, ssid);
     return ResponseEntity.noContent().build();
   }
 }

src/main/java/com/maradona/backend/controllers/api/FormOfAdressController.java

@@ -37,13 +37,13 @@ class FormOfAdressController {
   /**
    * Returns the form of address with the given ID.
    * 
-   * @param id The ID of the form of address to return.
+   * @param fid The ID of the form of address to return.
    * @return The description of the form of address with the given ID.
    * @see com.maradona.backend.entities.FormOfAddress
    */
   @GetMapping({ "/", "" })
-  public ResponseEntity<FormOfAddress> getFormOfAdress(@RequestParam Long id) {
+  public ResponseEntity<FormOfAddress> getFormOfAdress(@RequestParam Long fid) {
-    return formOfAdressService.getFormOfAddressById(id)
+    return formOfAdressService.getFormOfAddressByFid(fid)
         .map(ResponseEntity::ok)
         .orElse(ResponseEntity.notFound().build());
   }
@@ -78,14 +78,14 @@ class FormOfAdressController {
   /**
    * Updates the description of a form of address.
    * 
-   * @param id          The ID of the form of address to update.
+   * @param fid         The ID of the form of address to update.
    * @param description The new description of the form of address.
    * @return The updated form of address.
    * @see com.maradona.backend.entities.FormOfAddress
    */
   @PutMapping({ "/", "" })
-  public ResponseEntity<Void> updateFormOfAdress(@RequestParam Long id, @RequestBody String description) {
+  public ResponseEntity<Void> updateFormOfAdress(@RequestParam Long fid, @RequestBody String description) {
-    var formOfAddress = formOfAdressService.getFormOfAddressById(id).orElse(null);
+    var formOfAddress = formOfAdressService.getFormOfAddressByFid(fid).orElse(null);
     if (formOfAddress == null) {
       return ResponseEntity.notFound().build();
     }
@@ -97,17 +97,17 @@ class FormOfAdressController {
   /**
    * Deletes a form of address.
    * 
-   * @param id The ID of the form of address to delete.
+   * @param fid The ID of the form of address to delete.
    * @return The deleted form of address.
    * @see com.maradona.backend.entities.FormOfAddress
    */
   @DeleteMapping({ "/", "" })
-  public ResponseEntity<Void> deleteFormOfAdress(@RequestParam Long id) {
+  public ResponseEntity<Void> deleteFormOfAdress(@RequestParam Long fid) {
-    var formOfAddress = formOfAdressService.getFormOfAddressById(id).orElse(null);
+    var formOfAddress = formOfAdressService.getFormOfAddressByFid(fid).orElse(null);
     if (formOfAddress == null) {
       return ResponseEntity.notFound().build();
     }
-    formOfAdressService.deleteFormOfAddress(id);
+    formOfAdressService.deleteFormOfAddress(fid);
     return ResponseEntity.ok().build();
   }
 }

src/main/java/com/maradona/backend/controllers/api/PrimarySkillController.java

@@ -42,13 +42,13 @@ public class PrimarySkillController {
   /**
    * Returns a specific primary skill from the database.
    * 
-   * @param id The ID of the requested primary skill.
+   * @param pid The ID of the requested primary skill.
    * @return The primary skill with the requested ID.
    * @see com.maradona.backend.entities.PrimarySkill
    */
   @GetMapping({ "/", "" })
-  public ResponseEntity<PrimarySkill> get(@RequestParam Long id) {
+  public ResponseEntity<PrimarySkill> get(@RequestParam Long pid) {
-    return primarySkillService.getPrimarySkillById(id)
+    return primarySkillService.getPrimarySkillByPsid(pid)
         .map(ResponseEntity::ok)
         .orElse(ResponseEntity.notFound().build());
   }
@@ -93,21 +93,21 @@ public class PrimarySkillController {
   /**
    * Deletes a primary skill from the database.
    * 
-   * @param id The ID of the primary skill to be deleted
+   * @param pid The ID of the primary skill to be deleted
    * @return HTTP status indicating the outcome of the operation
    * @see com.maradona.backend.entities.PrimarySkill
    */
   @DeleteMapping({ "/", "" })
-  public ResponseEntity<Void> delete(@RequestParam Long id) {
+  public ResponseEntity<Void> delete(@RequestParam Long pid) {
-    var primarySkill = primarySkillService.getPrimarySkillById(id);
+    var primarySkill = primarySkillService.getPrimarySkillByPsid(pid);
     if (primarySkill.isPresent()) {
       var secondarySkills = secondarySkillService.getAllSecondarySkills();
       for (SecondarySkill secondarySkill : secondarySkills) {
-        if (secondarySkill.getPrimarySkill().getPsid().equals(id)) {
+        if (secondarySkill.getPrimarySkill().getPsid().equals(pid)) {
           secondarySkillService.deleteSecondarySkill(secondarySkill.getSsid());
         }
       }
-      primarySkillService.deletePrimarySkill(id);
+      primarySkillService.deletePrimarySkill(pid);
       return ResponseEntity.noContent().build();
     } else {
       return ResponseEntity.notFound().build();

src/main/java/com/maradona/backend/controllers/api/ProjectController.java

@@ -41,13 +41,13 @@ public class ProjectController {
   /**
    * Returns a specific project from the database.
    * 
-   * @param id The ID of the requested project.
+   * @param psid The ID of the requested project.
    * @return The project with the requested ID.
    * @see com.maradona.backend.entities.Project
    */
   @GetMapping({ "/", "" })
-  public ResponseEntity<Project> get(@RequestParam Long id) {
+  public ResponseEntity<Project> get(@RequestParam Long psid) {
-    Optional<Project> project = projectService.getProjectById(id);
+    Optional<Project> project = projectService.getProjectByPid(psid);
     return project.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());
   }
 
@@ -63,15 +63,15 @@ public class ProjectController {
   }
 
   /**
-   * Returns a list of projects for a given user.
+   * Returns a list of projects for a given employee.
    * 
-   * @param userId ID of the user
+   * @param eid ID of the employee
    * @return list of projects
    * @see com.maradona.backend.entities.Project
    */
-  @GetMapping("/from-user")
+  @GetMapping("/from-employee")
-  public ResponseEntity<Iterable<Project>> getFromUser(@RequestParam Long userId) {
+  public ResponseEntity<Iterable<Project>> getFromUser(@RequestParam Long eid) {
-    return ResponseEntity.ok(projectService.getProjectsByUserId(userId));
+    return ResponseEntity.ok(projectService.getProjectsByEid(eid));
   }
 
   /**
@@ -103,13 +103,13 @@ public class ProjectController {
   /**
    * Deletes a project from the database.
    * 
-   * @param id The ID of the project to be deleted
+   * @param pid The ID of the project to be deleted
    * @return HTTP status indicating the outcome of the operation
    * @see com.maradona.backend.entities.Project
    */
   @DeleteMapping({ "/", "" })
-  public ResponseEntity<Void> delete(@RequestParam Long id) {
+  public ResponseEntity<Void> delete(@RequestParam Long pid) {
-    projectService.deleteProject(id);
+    projectService.deleteProject(pid);
     return ResponseEntity.noContent().build();
   }
 }

src/main/java/com/maradona/backend/controllers/api/SecondarySkillController.java

@@ -40,13 +40,13 @@ public class SecondarySkillController {
   /**
    * Returns a specific secondary skill from the database.
    * 
-   * @param id The ID of the requested secondary skill.
+   * @param ssid The ID of the requested secondary skill.
    * @return The secondary skill with the requested ID.
    * @see com.maradona.backend.entities.SecondarySkill
    */
   @GetMapping({ "/", "" })
-  public ResponseEntity<SecondarySkill> get(@RequestParam Long id) {
+  public ResponseEntity<SecondarySkill> get(@RequestParam Long ssid) {
-    Optional<SecondarySkill> secondarySkill = secondarySkillService.getSecondarySkillById(id);
+    Optional<SecondarySkill> secondarySkill = secondarySkillService.getSecondarySkillBySsid(ssid);
     return secondarySkill.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());
   }
 
@@ -64,14 +64,14 @@ public class SecondarySkillController {
   /**
    * Returns a list of secondary skills for a given primary skill.
    * 
-   * @param primarySkillId ID of the primary skill
+   * @param psid ID of the primary skill
    * @return list of secondary skills
    * @see com.maradona.backend.entities.SecondarySkill
    * @see com.maradona.backend.entities.PrimarySkill
    */
   @GetMapping("/from-primary-skill")
-  public ResponseEntity<Iterable<SecondarySkill>> getSecondarySkills(@RequestParam Long primarySkillId) {
+  public ResponseEntity<Iterable<SecondarySkill>> getSecondarySkills(@RequestParam Long psid) {
-    return ResponseEntity.ok(secondarySkillService.getSecondarySkillsByPrimarySkillId(primarySkillId));
+    return ResponseEntity.ok(secondarySkillService.getSecondarySkillsByPrimarySkillId(psid));
   }
 
   /**
@@ -103,13 +103,13 @@ public class SecondarySkillController {
   /**
    * Deletes a secondary skill from the database.
    * 
-   * @param id The ID of the secondary skill to be deleted
+   * @param ssid The ID of the secondary skill to be deleted
    * @return HTTP status indicating the outcome of the operation
    * @see com.maradona.backend.entities.SecondarySkill
    */
   @DeleteMapping({ "/", "" })
-  public ResponseEntity<Void> delete(@RequestParam Long id) {
+  public ResponseEntity<Void> delete(@RequestParam Long ssid) {
-    secondarySkillService.deleteSecondarySkill(id);
+    secondarySkillService.deleteSecondarySkill(ssid);
     return ResponseEntity.noContent().build();
   }
 }

src/main/java/com/maradona/backend/controllers/page/SkillsPage.java

@@ -52,7 +52,7 @@ public class SkillsPage {
    */
   @GetMapping({ "/", "" })
   public String profile(Model model) {
-    model.addAttribute("employee", employeeService.getEmployeeById(user).orElse(null));
+    model.addAttribute("employee", employeeService.getEmployeeByEid(user).orElse(null));
     model.addAttribute("skills", skillService.getUserSkills(user));
     return "/pages/skills/overview";
   }

src/main/java/com/maradona/backend/dto/SkillPrototype.java

@@ -1,24 +1,24 @@
 package com.maradona.backend.dto;
 
 public class SkillPrototype {
-  private Long primarySkillId;
+  private Long psid;
-  private Long secondarySkillId;
+  private Long ssid;
   private Integer level;
 
-  public Long getPrimarySkillId() {
+  public Long getPsid() {
-    return primarySkillId;
+    return psid;
   }
 
-  public void setPrimarySkillId(Long primarySkillId) {
+  public void setPsid(Long psid) {
-    this.primarySkillId = primarySkillId;
+    this.psid = psid;
   }
 
-  public Long getSecondarySkillId() {
+  public Long getSsid() {
-    return secondarySkillId;
+    return ssid;
   }
 
-  public void setSecondarySkillId(Long secondarySkillId) {
+  public void setSsid(Long ssid) {
-    this.secondarySkillId = secondarySkillId;
+    this.ssid = ssid;
   }
 
   public Integer getLevel() {

src/main/java/com/maradona/backend/entities/Employee.java

@@ -2,6 +2,7 @@ package com.maradona.backend.entities;
 
 import jakarta.persistence.*;
 import lombok.Data;
+import com.fasterxml.jackson.annotation.JsonManagedReference;
 import java.time.LocalTime;
 import java.util.List;
 import java.util.Map;
@@ -10,10 +11,9 @@ import java.util.stream.Collectors;
 @Entity
 @Data
 public class Employee {
-
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
+    private Long eid;
 
     private Integer employeeNr;
 
@@ -24,15 +24,24 @@ public class Employee {
     private String lastName;
 
     @ManyToOne
-    @JoinColumn(name = "AID")
+    @JoinColumn(name = "FID")
     private FormOfAddress formOfAddress;
 
     private LocalTime dStart;
     private LocalTime dEnd;
 
     @OneToMany(mappedBy = "employee", cascade = CascadeType.ALL, orphanRemoval = true)
+    @JsonManagedReference
     private List<EmployeeSecondarySkill> secondarySkills;
 
+    public void setEid(Long eid) {
+        this.eid = eid;
+    }
+
+    public Long getEid() {
+        return eid;
+    }
+
     public void setEmployeeNr(Integer employeeNr) {
         this.employeeNr = employeeNr;
     }

src/main/java/com/maradona/backend/entities/EmployeeSecondarySkill.java

@@ -1,36 +1,34 @@
 package com.maradona.backend.entities;
 
 import jakarta.persistence.*;
-import com.fasterxml.jackson.annotation.JsonBackReference;
 import lombok.Data;
+import com.fasterxml.jackson.annotation.JsonBackReference;
 
 @Entity
 @Data
 public class EmployeeSecondarySkill {
-
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
-  private Long id;
+  private Long essid;
 
   @ManyToOne
-  @JoinColumn(name = "employee_id", nullable = false)
+  @JoinColumn(name = "employee_eid", nullable = false)
   @JsonBackReference
   private Employee employee;
 
   @ManyToOne
   @JoinColumn(name = "secondary_skill_id", nullable = false)
-  @JsonBackReference
   private SecondarySkill secondarySkill;
 
   @Column(nullable = false)
   private Integer level;
 
-  public void setId(Long id) {
+  public void setEssid(Long essid) {
-    this.id = id;
+    this.essid = essid;
   }
 
-  public Long getId() {
+  public Long getEssid() {
-    return id;
+    return essid;
   }
 
   public void setEmployee(Employee employee) {

src/main/java/com/maradona/backend/entities/FormOfAddress.java

@@ -9,17 +9,17 @@ public class FormOfAddress {
 
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
+    private Long fid;
 
     @Column(nullable = false, length = 50)
     private String description;
 
-    public void setId(Long id) {
+    public void setFid(Long fid) {
-        this.id = id;
+        this.fid = fid;
     }
 
-    public Long getId() {
+    public Long getFid() {
-        return id;
+        return fid;
     }
 
     public void setDescription(String description) {

src/main/java/com/maradona/backend/entities/Project.java

@@ -10,7 +10,7 @@ public class Project {
 
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)
-    private Long id;
+    private Long pid;
 
     @Column(nullable = false, length = 255)
     private String name;
@@ -23,6 +23,14 @@ public class Project {
     @Column(columnDefinition = "TEXT")
     private String description;
 
+    public void setPid(Long pid) {
+        this.pid = pid;
+    }
+
+    public Long getPid() {
+        return pid;
+    }
+
     public void setName(String name) {
         this.name = name;
     }

src/main/java/com/maradona/backend/repositories/EmployeeSecondarySkillRepository.java

@@ -2,8 +2,6 @@ package com.maradona.backend.repositories;
 
 import org.springframework.data.repository.CrudRepository;
 import com.maradona.backend.entities.EmployeeSecondarySkill;
-import java.util.List;
 
 public interface EmployeeSecondarySkillRepository extends CrudRepository<EmployeeSecondarySkill, Long> {
-  List<EmployeeSecondarySkill> findByEmployeeId(Long employeeId);
 }

src/main/java/com/maradona/backend/services/EmployeeService.java

@@ -21,25 +21,36 @@ public class EmployeeService {
     return employeeRepository.save(employee);
   }
 
-  public Optional<Employee> getEmployeeById(Long id) {
+  public Optional<Employee> getEmployeeByEid(Long eid) {
-    return employeeRepository.findById(id);
+    var employees = employeeRepository.findAll();
+    for (Employee employee : employees) {
+      if (employee.getEid().equals(eid)) {
+        return Optional.of(employee);
+      }
+    }
+    return Optional.empty();
   }
 
-  public void deleteEmployee(Long id) {
+  public void deleteEmployee(Long eid) {
-    employeeRepository.deleteById(id);
+    for (Employee employee : employeeRepository.findAll()) {
+      if (employee.getEid().equals(eid)) {
+        employeeRepository.delete(employee);
+        return;
+      }
+    }
   }
 
   public Iterable<Employee> getAllEmployees() {
     return employeeRepository.findAll();
   }
 
-  public void addSecondarySkillToEmployee(Long userId, SkillPrototype skillPrototype) {
+  public void addSecondarySkillToEmployee(Long eid, SkillPrototype skillPrototype) {
-    var employee = getEmployeeById(userId).orElseThrow(() -> new RuntimeException("Employee not found"));
+    var employee = getEmployeeByEid(eid).orElseThrow(() -> new RuntimeException("Employee not found"));
-    var secondarySkill = secondarySkillService.getSecondarySkillById(skillPrototype.getSecondarySkillId())
+    var secondarySkill = secondarySkillService.getSecondarySkillBySsid(skillPrototype.getSsid())
         .orElseThrow(() -> new RuntimeException("Secondary Skill not found"));
 
     for (EmployeeSecondarySkill skill : employee.getSecondarySkills()) {
-      if (skill.getSecondarySkill().getSsid().equals(skillPrototype.getSecondarySkillId())) {
+      if (skill.getSecondarySkill().getSsid().equals(skillPrototype.getSsid())) {
         return;
       }
     }
@@ -52,13 +63,14 @@ public class EmployeeService {
     saveEmployee(employee);
   }
 
-  public void updateSecondarySkillLevel(Long userId, Long skillId, Integer level) {
+  public void updateSecondarySkillLevel(Long eid, Long ssid, Integer level) {
-    var employee = getEmployeeById(userId).orElseThrow(() -> new RuntimeException("Employee not found"));
+    var employee = getEmployeeByEid(eid).orElseThrow(() -> new RuntimeException("Employee not found"));
-    secondarySkillService.getSecondarySkillById(skillId)
+    secondarySkillService.getSecondarySkillBySsid(
+        ssid)
         .orElseThrow(() -> new RuntimeException("Secondary Skill not found"));
 
     for (EmployeeSecondarySkill skill : employee.getSecondarySkills()) {
-      if (skill.getSecondarySkill().getSsid().equals(skillId)) {
+      if (skill.getSecondarySkill().getSsid().equals(ssid)) {
         skill.setLevel(level);
         break;
       }
@@ -67,18 +79,19 @@ public class EmployeeService {
     saveEmployee(employee);
   }
 
-  public void deleteSecondarySkillFromEmployee(Long userId, Long skillId) {
+  public void deleteSecondarySkillFromEmployee(Long eid, Long ssid) {
-    var employee = getEmployeeById(userId).orElseThrow(() -> new RuntimeException("Employee not found"));
+    var employee = getEmployeeByEid(eid).orElseThrow(() -> new RuntimeException("Employee not found"));
-    secondarySkillService.getSecondarySkillById(skillId)
+    secondarySkillService.getSecondarySkillBySsid(
+        ssid)
         .orElseThrow(() -> new RuntimeException("Secondary Skill not found"));
 
-    employee.getSecondarySkills().removeIf(skill -> skill.getSecondarySkill().getSsid().equals(skillId));
+    employee.getSecondarySkills().removeIf(skill -> skill.getSecondarySkill().getSsid().equals(ssid));
     saveEmployee(employee);
   }
 
-  public Iterable<Employee> getEmployeesBySecondarySkill(Long skillId, Integer level) {
+  public Iterable<Employee> getEmployeesBySecondarySkill(Long ssid, Integer level) {
     // Implement logic to fetch employees by secondary skill and level
-    // This is a placeholder implementation
+    // TODO: This is a placeholder implementation
     return employeeRepository.findAll();
   }
 }

src/main/java/com/maradona/backend/services/FormOfAddressService.java

@@ -17,25 +17,32 @@ public class FormOfAddressService {
     return formOfAddressRepository.save(formOfAddress);
   }
 
-  public Optional<FormOfAddress> getFormOfAddressById(Long id) {
+  public Optional<FormOfAddress> getFormOfAddressByFid(Long fid) {
-    return formOfAddressRepository.findById(id);
+    var formOfAddresses = formOfAddressRepository.findAll();
+    for (FormOfAddress formOfAddress : formOfAddresses) {
+      if (formOfAddress.getFid().equals(fid)) {
+        return Optional.of(formOfAddress);
+      }
+    }
+    return Optional.empty();
   }
 
-  public void deleteFormOfAddress(Long id) {
+  public void deleteFormOfAddress(Long fid) {
-    formOfAddressRepository.deleteById(id);
+    for (FormOfAddress formOfAddress : formOfAddressRepository.findAll()) {
+      if (formOfAddress.getFid().equals(fid)) {
+        formOfAddressRepository.delete(formOfAddress);
+        return;
+      }
+    }
   }
 
   public Iterable<FormOfAddress> getAllFormOfAddresses() {
     return formOfAddressRepository.findAll();
   }
 
-  public Long updateFormOfAddress(Long id, String description) {
+  public void updateFormOfAddress(Long fid, String description) {
-    var formOfAddress = formOfAddressRepository.findById(id).orElse(null);
+    var formOfAddress = getFormOfAddressByFid(fid).orElseThrow(() -> new RuntimeException("Form of Address not found"));
-    if (formOfAddress != null) {
+    formOfAddress.setDescription(description);
-      formOfAddress.setDescription(description);
+    saveFormOfAddress(formOfAddress);
-      formOfAddressRepository.save(formOfAddress);
-      return id;
-    }
-    return null;
   }
 }

src/main/java/com/maradona/backend/services/PrimarySkillService.java

@@ -3,6 +3,7 @@ package com.maradona.backend.services;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import com.maradona.backend.entities.PrimarySkill;
+import com.maradona.backend.entities.SecondarySkill;
 import com.maradona.backend.repositories.PrimarySkillRepository;
 
 import java.util.Optional;
@@ -13,16 +14,36 @@ public class PrimarySkillService {
   @Autowired
   private PrimarySkillRepository primarySkillRepository;
 
+  @Autowired
+  private SecondarySkillService secondarySkillRepository;
+
   public PrimarySkill savePrimarySkill(PrimarySkill primarySkill) {
     return primarySkillRepository.save(primarySkill);
   }
 
-  public Optional<PrimarySkill> getPrimarySkillById(Long id) {
+  public Optional<PrimarySkill> getPrimarySkillByPsid(Long psid) {
-    return primarySkillRepository.findById(id);
+    var primarySkills = primarySkillRepository.findAll();
+    for (PrimarySkill primarySkill : primarySkills) {
+      if (primarySkill.getPsid().equals(psid)) {
+        return Optional.of(primarySkill);
+      }
+    }
+    return Optional.empty();
   }
 
-  public void deletePrimarySkill(Long id) {
+  public void deletePrimarySkill(Long psid) {
-    primarySkillRepository.deleteById(id);
+    var primarySkills = primarySkillRepository.findAll();
+    var secondarySkills = secondarySkillRepository.getAllSecondarySkills();
+    for (SecondarySkill secondarySkill : secondarySkills) {
+      if (secondarySkill.getPrimarySkill().getPsid().equals(psid)) {
+        secondarySkillRepository.deleteSecondarySkill(secondarySkill.getSsid());
+      }
+    }
+    for (PrimarySkill primarySkill : primarySkills) {
+      if (primarySkill.getPsid().equals(psid)) {
+        primarySkillRepository.delete(primarySkill);
+      }
+    }
   }
 
   public Iterable<PrimarySkill> getAllPrimarySkills() {

src/main/java/com/maradona/backend/services/ProjectService.java

@@ -17,19 +17,30 @@ public class ProjectService {
     return projectRepository.save(project);
   }
 
-  public Optional<Project> getProjectById(Long id) {
+  public Optional<Project> getProjectByPid(Long pid) {
-    return projectRepository.findById(id);
+    var projects = projectRepository.findAll();
+    for (Project project : projects) {
+      if (project.getPid().equals(pid)) {
+        return Optional.of(project);
+      }
+    }
+    return Optional.empty();
   }
 
-  public void deleteProject(Long id) {
+  public void deleteProject(Long pid) {
-    projectRepository.deleteById(id);
+    var projects = projectRepository.findAll();
+    for (Project project : projects) {
+      if (project.getPid().equals(pid)) {
+        projectRepository.delete(project);
+      }
+    }
   }
 
   public Iterable<Project> getAllProjects() {
     return projectRepository.findAll();
   }
 
-  public Iterable<Project> getProjectsByUserId(Long userId) {
+  public Iterable<Project> getProjectsByEid(Long eid) {
     // TODO: Actually filter by user
     return projectRepository.findAll();
   }

src/main/java/com/maradona/backend/services/SecondarySkillService.java

@@ -28,23 +28,29 @@ public class SecondarySkillService {
     return secondarySkillRepository.save(secondarySkill);
   }
 
-  public Optional<SecondarySkill> getSecondarySkillById(Long id) {
+  public Optional<SecondarySkill> getSecondarySkillBySsid(Long ssid) {
-    return secondarySkillRepository.findById(id);
+    var secondarySkills = secondarySkillRepository.findAll();
+    for (SecondarySkill secondarySkill : secondarySkills) {
+      if (secondarySkill.getSsid().equals(ssid)) {
+        return Optional.of(secondarySkill);
+      }
+    }
+    return Optional.empty();
   }
 
-  public void deleteSecondarySkill(Long id) {
+  public void deleteSecondarySkill(Long ssid) {
-    secondarySkillRepository.deleteById(id);
+    secondarySkillRepository.deleteById(ssid);
   }
 
   public Iterable<SecondarySkill> getAllSecondarySkills() {
     return secondarySkillRepository.findAll();
   }
 
-  public Iterable<SecondarySkill> getSecondarySkillsByPrimarySkillId(Long primarySkillId) {
+  public Iterable<SecondarySkill> getSecondarySkillsByPrimarySkillId(Long psid) {
     var skills = secondarySkillRepository.findAll();
     var result = new java.util.ArrayList<SecondarySkill>();
     for (SecondarySkill skill : skills) {
-      if (skill.getPrimarySkill().getPsid().equals(primarySkillId)) {
+      if (skill.getPrimarySkill().getPsid().equals(psid)) {
         result.add(skill);
         System.out.println(skill.getDescription());
       }

src/main/java/com/maradona/backend/services/SkillService.java

@@ -4,9 +4,6 @@ import com.maradona.backend.dto.SkillList;
 import com.maradona.backend.entities.Employee;
 import com.maradona.backend.entities.PrimarySkill;
 import com.maradona.backend.entities.SecondarySkill;
-import com.maradona.backend.repositories.EmployeeRepository;
-import com.maradona.backend.repositories.PrimarySkillRepository;
-import com.maradona.backend.repositories.SecondarySkillRepository;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.data.util.Pair;
@@ -19,24 +16,24 @@ import java.util.Map;
 public class SkillService {
 
   @Autowired
-  private PrimarySkillRepository primarySkillRepository;
+  private PrimarySkillService primarySkillService;
 
   @Autowired
-  private SecondarySkillRepository secondarySkillRepository;
+  private SecondarySkillService secondarySkillService;
 
   @Autowired
-  private EmployeeRepository employeeRepository;
+  private EmployeeService employeeService;
 
   public Iterable<SkillList> getAllSkills() {
-    Iterable<PrimarySkill> primarySkills = primarySkillRepository.findAll();
+    Iterable<PrimarySkill> primarySkills = primarySkillService.getAllPrimarySkills();
-    Iterable<SecondarySkill> secondarySkills = secondarySkillRepository.findAll();
+    Iterable<SecondarySkill> secondarySkills = secondarySkillService.getAllSecondarySkills();
     List<SkillList> skills = new ArrayList<>();
 
     for (PrimarySkill primarySkill : primarySkills) {
       List<Pair<SecondarySkill, Integer>> secondarySkillList = new ArrayList<>();
       for (SecondarySkill secondarySkill : secondarySkills) {
         if (secondarySkill.getPrimarySkill().getPsid().equals(primarySkill.getPsid())) {
-          secondarySkillList.add(Pair.of(secondarySkill, 3)); // Placeholder level
+          secondarySkillList.add(Pair.of(secondarySkill, 3));
         }
       }
       skills.add(new SkillList(primarySkill, secondarySkillList));
@@ -44,11 +41,11 @@ public class SkillService {
     return skills;
   }
 
-  public Iterable<SkillList> getUserSkills(Long userId) {
+  public Iterable<SkillList> getUserSkills(Long eid) {
-    if (userId == null) {
+    if (eid == null) {
       return new ArrayList<>();
     }
-    Employee employee = employeeRepository.findById(userId).orElse(null);
+    Employee employee = employeeService.getEmployeeByEid(eid).orElse(null);
     if (employee == null) {
       return new ArrayList<>();
     }
@@ -56,7 +53,7 @@ public class SkillService {
     Map<SecondarySkill, Integer> secondarySkillLevels = employee.getSecondarySkillLevels();
     List<SkillList> skills = new ArrayList<>();
 
-    for (PrimarySkill primarySkill : primarySkillRepository.findAll()) {
+    for (PrimarySkill primarySkill : primarySkillService.getAllPrimarySkills()) {
       List<Pair<SecondarySkill, Integer>> secondarySkillList = new ArrayList<>();
       for (Map.Entry<SecondarySkill, Integer> entry : secondarySkillLevels.entrySet()) {
         if (entry.getKey().getPrimarySkill().getPsid().equals(primarySkill.getPsid())) {

src/test/java/com/maradona/backend/controllers/api/EmployeeControllerTest.java

@@ -0,0 +1,171 @@
+package com.maradona.backend.controllers.api;
+
+import com.maradona.backend.controllers.api.EmployeeController;
+import com.maradona.backend.entities.Employee;
+import com.maradona.backend.services.EmployeeService;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+
+import java.time.LocalTime;
+import java.util.List;
+import java.util.Optional;
+
+import static org.mockito.Mockito.when;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+
+@WebMvcTest(EmployeeController.class)
+public class EmployeeControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private EmployeeService employeeService;
+
+    @Test
+    public void testGetEmployeeById() throws Exception {
+        // Arrange: Mock an employee
+        Employee employee = new Employee();
+        employee.setId(1L);
+        employee.setEmployeeNr(123);
+        employee.setFirstName("John");
+        employee.setLastName("Doe");
+        employee.setDStart(LocalTime.of(9, 0));
+        employee.setDEnd(LocalTime.of(17, 0));
+
+        // Assuming FormOfAddress and EmployeeSecondarySkill are also set up if needed for your test.
+        when(employeeService.getEmployeeById(1L)).thenReturn(Optional.of(employee));
+
+        // Act & Assert: Send GET request and expect a 200 OK status and JSON response
+        mockMvc.perform(get("/api/employee")
+                        .param("id", "1")
+                        .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.id").value(1))
+                .andExpect(jsonPath("$.employeeNr").value(123))
+                .andExpect(jsonPath("$.firstName").value("John"))
+                .andExpect(jsonPath("$.lastName").value("Doe"))
+                .andExpect(jsonPath("$.dStart").value("09:00:00"))
+                .andExpect(jsonPath("$.dEnd").value("17:00:00"));
+    }
+
+    //Test if an employee is not found (404 Not Found)
+    @Test
+    public void testGetEmployeeByIdNotFound() throws Exception {
+        //Arrange
+        when(employeeService.getEmployeeById(999L)).thenReturn(Optional.empty());
+
+        //Act & Assert: Send GET request and expect a 404 Not Found status
+        mockMvc.perform(get("/api/employee")
+                        .param("id", "999")
+                        .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isNotFound());
+    }
+
+
+    //Testing the getAll method for all employees
+    @Test
+    public void testGetAllEmployees() throws Exception {
+        //Arrange: Mock a list of employees
+        Employee employee1 = new Employee();
+        employee1.setId(1L);
+        employee1.setEmployeeNr(123);
+        employee1.setFirstName("Mohammad");
+        employee1.setLastName("Hawrami");
+
+        Employee employee2 = new Employee();
+        employee2.setId(2L);
+        employee2.setEmployeeNr(124);
+        employee2.setFirstName("Tarik");
+        employee2.setLastName("Gökmen");
+
+        when(employeeService.getAllEmployees()).thenReturn(List.of(employee1, employee2));
+
+        //Act & Assert: Send GET request and expect a 200 OK status and JSON array response
+        mockMvc.perform(get("/api/employees/all")
+                        .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$[0].employeeNr").value(1))
+                .andExpect(jsonPath("$[1].employeeNr").value(2));
+    }
+
+
+    //Testing the getFromSkill method with a specific Skilld and level
+    @Test
+    public void testGetEmployeesBySecondarySkill() throws Exception {
+        //Arrange: Mock a list of employees with specific skills
+        Employee employee = new Employee();
+        employee.setId(1L);
+        employee.setEmployeeNr(123);
+        employee.setFirstName("Mohammad");
+        employee.setLastName("Hawrami");
+
+        when(employeeService.getEmployeesBySecondarySkill(1L,2)).thenReturn(List.of(employee));
+
+        //Act & Assert: Send GET request and expect a 200 OK status and JSON array response
+        mockMvc.perform(get("/api/employee/from-skill")
+                        .param("skillId", "1")
+                        .param("level", "2")
+                        .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$[0].id").value(1))
+                .andExpect(jsonPath("$[0].employeeNr").value(123));
+    }
+
+
+    //Testing the postSkillPrototype method with a valid SkillPrototype object
+    @Test
+    public void testPostSkillPrototype() throws Exception {
+        //Arrange: Create a SkillPrototype JSON payload
+        String skillPrototypeJson = "{\"skillId\":\"1\",\"level\":\"3\"}";
+
+        //Act & Assert: Send POST request and expect a 201 Creat status
+        mockMvc.perform(post("/api/employee/skill/prototype")
+                        .content(skillPrototypeJson)
+                        .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isCreated());
+    }
+
+
+    //Testing the putSkillLevel method to update an existing level
+    @Test
+    public void testPutSkillLevel() throws Exception {
+        // Act & Assert: Send PUT request and expect a 200 OK status
+        mockMvc.perform(put("/api/employee/skill/level")
+                        .param("skillId", "1")
+                        .param("level", "5")
+                        .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk());
+    }
+
+
+    //Testing the delete method for removing a secondary skill java
+    @Test
+    public void testDeleteSecondarySkill() throws Exception {
+        // Act & Assert: Send DELETE request and expect a 204 No Content status
+        mockMvc.perform(delete("/api/employee/skill")
+                        .param("id", "1")
+                        .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isNoContent());
+    }
+
+
+    //Testing the postSkillPrototype methode with invalid payload (e.g., no Skilld)
+    @Test
+    public void testPostSkillPrototype_BadRequest() throws Exception {
+        // Arrange: Create an invalid JSON payload (missing skillId)
+        String invalidSkillPrototypeJson = "{\"level\":3}";
+
+        // Act & Assert: Send POST request and expect a 400 Bad Request status
+        mockMvc.perform(post("/api/employee/skill/prototype")
+                        .content(invalidSkillPrototypeJson)
+                        .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isBadRequest());
+    }
+}

src/test/java/com/maradona/backend/controllers/api/FormOfAdressControllerTest.java

@@ -0,0 +1,131 @@
+package com.maradona.backend.controllers.api;
+
+import com.maradona.backend.entities.FormOfAddress;
+import com.maradona.backend.services.FormOfAddressService;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+
+import java.util.Optional;
+import java.util.Arrays;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+
+@WebMvcTest(FormOfAdressController.class)
+public class FormOfAdressControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private FormOfAddressService formOfAdressService;
+
+    @Test
+    public void testGetFormOfAdressById() throws Exception {
+        FormOfAddress formOfAddress = new FormOfAddress();
+        formOfAddress.setId(1L);
+        formOfAddress.setDescription("Mr.");
+
+        when(formOfAdressService.getFormOfAddressById(1L)).thenReturn(Optional.of(formOfAddress));
+
+        mockMvc.perform(get("/api/form-of-adress")
+                .param("id", "1")
+                .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.id").value(1))
+                .andExpect(jsonPath("$.description").value("Mr."));
+    }
+
+    @Test
+    public void testGetAllFormOfAdresses() throws Exception {
+        FormOfAddress form1 = new FormOfAddress();
+        form1.setId(1L);
+        form1.setDescription("Mr.");
+
+        FormOfAddress form2 = new FormOfAddress();
+        form2.setId(2L);
+        form2.setDescription("Ms.");
+
+        when(formOfAdressService.getAllFormOfAddresses()).thenReturn(Arrays.asList(form1, form2));
+
+        mockMvc.perform(get("/api/form-of-adress/all")
+                .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$[0].id").value(1))
+                .andExpect(jsonPath("$[0].description").value("Mr."))
+                .andExpect(jsonPath("$[1].id").value(2))
+                .andExpect(jsonPath("$[1].description").value("Ms."));
+    }
+
+    @Test
+    public void testCreateFormOfAdress() throws Exception {
+        FormOfAddress formOfAddress = new FormOfAddress();
+        formOfAddress.setId(1L);
+        formOfAddress.setDescription("Dr.");
+
+        when(formOfAdressService.saveFormOfAddress(any(FormOfAddress.class))).thenReturn(formOfAddress);
+
+        mockMvc.perform(post("/api/form-of-adress")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content("\"Dr.\""))
+                .andExpect(status().isOk());
+    }
+
+    @Test
+    public void testUpdateFormOfAdress() throws Exception {
+        FormOfAddress existingForm = new FormOfAddress();
+        existingForm.setId(1L);
+        existingForm.setDescription("Mr.");
+
+        when(formOfAdressService.getFormOfAddressById(1L)).thenReturn(Optional.of(existingForm));
+
+        mockMvc.perform(put("/api/form-of-adress")
+                .param("id", "1")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content("\"Prof.\""))
+                .andExpect(status().isOk());
+    }
+
+    @Test
+    public void testUpdateFormOfAdressNotFound() throws Exception {
+        when(formOfAdressService.getFormOfAddressById(1L)).thenReturn(Optional.empty());
+
+        mockMvc.perform(put("/api/form-of-adress")
+                .param("id", "1")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content("\"Prof.\""))
+                .andExpect(status().isNotFound());
+    }
+
+    @Test
+    public void testDeleteFormOfAdress() throws Exception {
+        FormOfAddress formOfAddress = new FormOfAddress();
+        formOfAddress.setId(1L);
+        formOfAddress.setDescription("Mr.");
+
+        when(formOfAdressService.getFormOfAddressById(1L)).thenReturn(Optional.of(formOfAddress));
+
+        mockMvc.perform(delete("/api/form-of-adress")
+                .param("id", "1")
+                .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk());
+    }
+
+    @Test
+    public void testDeleteFormOfAdressNotFound() throws Exception {
+        when(formOfAdressService.getFormOfAddressById(1L)).thenReturn(Optional.empty());
+
+        mockMvc.perform(delete("/api/form-of-adress")
+                .param("id", "1")
+                .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isNotFound());
+    }
+}

src/test/java/com/maradona/backend/controllers/api/PrimarySkillControllerTest.java

@@ -0,0 +1,140 @@
+package com.maradona.backend.controllers.api;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.maradona.backend.entities.PrimarySkill;
+import com.maradona.backend.services.PrimarySkillService;
+import com.maradona.backend.services.SecondarySkillService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.*;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
+import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+
+import java.util.List;
+import java.util.Optional;
+
+import static org.mockito.ArgumentMatchers.any;
+
+public class PrimarySkillControllerTest {
+
+    private MockMvc mockMvc;
+
+    @Mock
+    private PrimarySkillService primarySkillService;
+
+    @Mock
+    private SecondarySkillService secondarySkillService;
+
+    @InjectMocks
+    private PrimarySkillController primarySkillController;
+
+    private PrimarySkill primarySkill;
+
+    @BeforeEach
+    public void setUp() {
+        MockitoAnnotations.openMocks(this);
+        mockMvc = MockMvcBuilders.standaloneSetup(primarySkillController).build();
+
+        // Initialisieren eines Beispiels für PrimarySkill
+        primarySkill = new PrimarySkill();
+        primarySkill.setPsid(1L);
+        primarySkill.setDescription("Test Primary Skill");
+    }
+
+    @Test
+    public void testGetPrimarySkillById_Success() throws Exception {
+        // Mock das Service, um ein PrimarySkill zu liefern
+        Mockito.when(primarySkillService.getPrimarySkillById(1L)).thenReturn(Optional.of(primarySkill));
+
+        // Führe die GET-Anfrage aus
+        mockMvc.perform(MockMvcRequestBuilders.get("/api/primary-skill")
+                        .param("id", "1"))
+                .andExpect(MockMvcResultMatchers.status().isOk())
+                .andExpect(MockMvcResultMatchers.jsonPath("$.psid").value(1))
+                .andExpect(MockMvcResultMatchers.jsonPath("$.description").value("Test Primary Skill"));
+
+        // Verifiziere, dass der Service aufgerufen wurde
+        Mockito.verify(primarySkillService, Mockito.times(1)).getPrimarySkillById(1L);
+    }
+
+    @Test
+    public void testGetAllPrimarySkills() throws Exception {
+        // Mock das Service, um eine Liste von PrimarySkills zu liefern
+        Mockito.when(primarySkillService.getAllPrimarySkills()).thenReturn(List.of(primarySkill));
+
+        // Führe die GET-Anfrage aus
+        mockMvc.perform(MockMvcRequestBuilders.get("/api/primary-skill/all"))
+                .andExpect(MockMvcResultMatchers.status().isOk())
+                .andExpect(MockMvcResultMatchers.jsonPath("$[0].psid").value(1))
+                .andExpect(MockMvcResultMatchers.jsonPath("$[0].description").value("Test Primary Skill"));
+
+        // Verifiziere, dass der Service aufgerufen wurde
+        Mockito.verify(primarySkillService, Mockito.times(1)).getAllPrimarySkills();
+    }
+
+    @Test
+    public void testCreatePrimarySkill() throws Exception {
+        // Mock das Service, um das PrimarySkill zu speichern
+        Mockito.when(primarySkillService.savePrimarySkill(ArgumentMatchers.any(PrimarySkill.class))).thenReturn(primarySkill);
+
+        // Führe die POST-Anfrage aus
+        mockMvc.perform(MockMvcRequestBuilders.post("/api/primary-skill")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(new ObjectMapper().writeValueAsString(primarySkill))) // Hier wird das PrimarySkill als JSON übermittelt
+                .andExpect(MockMvcResultMatchers.status().isCreated()) // Erwartet den Statuscode 201 Created
+                .andExpect(MockMvcResultMatchers.jsonPath("$.psid").value(1)) // Überprüft das psid in der Antwort
+                .andExpect(MockMvcResultMatchers.jsonPath("$.description").value("Test Primary Skill")); // Überprüft die Beschreibung
+
+        // Verifiziere, dass der Service aufgerufen wurde
+        Mockito.verify(primarySkillService, Mockito.times(1)).savePrimarySkill(ArgumentMatchers.any(PrimarySkill.class));
+    }
+
+
+    @Test
+    public void testUpdatePrimarySkill() throws Exception {
+        // Mock das Service, um das PrimarySkill zu speichern
+        Mockito.when(primarySkillService.savePrimarySkill(ArgumentMatchers.any(PrimarySkill.class))).thenReturn(primarySkill);
+
+        // Führe die PUT-Anfrage aus
+        mockMvc.perform(MockMvcRequestBuilders.put("/api/primary-skill")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(new ObjectMapper().writeValueAsString(primarySkill)))
+                .andExpect(MockMvcResultMatchers.status().isOk())
+                .andExpect(MockMvcResultMatchers.jsonPath("$.psid").value(1))
+                .andExpect(MockMvcResultMatchers.jsonPath("$.description").value("Test Primary Skill"));
+
+        // Verifiziere, dass der Service aufgerufen wurde
+        Mockito.verify(primarySkillService, Mockito.times(1)).savePrimarySkill(ArgumentMatchers.any(PrimarySkill.class));
+    }
+
+    @Test
+    public void testDeletePrimarySkill_Success() throws Exception {
+        // Mock das Service, um das PrimarySkill zu liefern
+        Mockito.when(primarySkillService.getPrimarySkillById(1L)).thenReturn(Optional.of(primarySkill));
+
+        // Führe die DELETE-Anfrage aus
+        mockMvc.perform(MockMvcRequestBuilders.delete("/api/primary-skill")
+                        .param("id", "1"))
+                .andExpect(MockMvcResultMatchers.status().isNoContent());
+
+        // Verifiziere, dass der Service aufgerufen wurde
+        Mockito.verify(primarySkillService, Mockito.times(1)).deletePrimarySkill(1L);
+    }
+
+    @Test
+    public void testDeletePrimarySkill_NotFound() throws Exception {
+        // Mock das Service, um das PrimarySkill nicht zu finden
+        Mockito.when(primarySkillService.getPrimarySkillById(1L)).thenReturn(Optional.empty());
+
+        // Führe die DELETE-Anfrage aus
+        mockMvc.perform(MockMvcRequestBuilders.delete("/api/primary-skill")
+                        .param("id", "1"))
+                .andExpect(MockMvcResultMatchers.status().isNotFound());
+
+        // Verifiziere, dass der Service nicht aufgerufen wurde
+        Mockito.verify(primarySkillService, Mockito.never()).deletePrimarySkill(1L);
+    }
+}

src/test/java/com/maradona/backend/controllers/api/ProjectControllerTest.java

@@ -0,0 +1,199 @@
+package com.maradona.backend.controllers.api;
+
+import com.maradona.backend.controllers.api.ProjectController;
+import com.maradona.backend.entities.Project;
+import com.maradona.backend.services.ProjectService;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+
+import java.time.LocalDate;
+import java.util.Arrays;
+import java.util.Optional;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+
+@WebMvcTest(ProjectController.class)
+public class ProjectControllerTest {
+    // MockMvc to simulate HTTP requests to the controller
+    @Autowired
+    private MockMvc mockMvc;
+
+    // Mocked ProjectService to simulate service calls
+    @MockBean
+    private ProjectService projectService;
+
+    @Test
+    public void testGetProjectById() throws Exception {
+        //Arrange: Mock an project
+        Project project = new Project();
+        project.setId(1L);
+        project.setName("Skillmanagementsystem erstellen");
+        project.setStartDate(LocalDate.of(2024, 11,8));
+        project.setEndDate(LocalDate.of(2024, 11,20));
+        project.setWorkload(12);
+        project.setDescription("Skillmanagementsystem erstellen für die Firma");
+
+        //Define the behavior of the mocked ProjectService: return the project when ID 1 is requested
+        when(projectService.getProjectById(1L)).thenReturn(Optional.of(project));
+
+        //Act & Assert: Send GET request an expect a 200 OK status and JSON response
+        //GET /api/project/
+        mockMvc.perform(get("/api/project")
+                        .param("id", "1")
+                        .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.id").value(1))
+                .andExpect(jsonPath("$.name").value("Skillmanagementsystem erstellen"))
+                .andExpect(jsonPath("$.startDate").value("2024-11-08"))
+                .andExpect(jsonPath("$.endDate").value("2024-11-20"))
+                .andExpect(jsonPath("$.workload").value(12))
+                .andExpect(jsonPath("$.description").value("Skillmanagementsystem erstellen für die Firma"));
+    }
+
+    @Test
+    public void testGetAllProjects() throws Exception {
+        //Arrange: Creat a list of mock projects
+        Project project = new Project();
+        project.setId(1L);
+        project.setName("Skillmanagementsystem erstellen");
+        project.setStartDate(LocalDate.of(2024, 11,8));
+        project.setEndDate(LocalDate.of(2024, 11,20));
+        project.setWorkload(12);
+        project.setDescription("Skillmanagementsystem erstellen für die Firma");
+
+        Project project2 = new Project();
+        project2.setId(2L);
+        project2.setName("EAFC 25");
+        project2.setStartDate(LocalDate.of(2024, 11,20));
+        project2.setEndDate(LocalDate.of(2024, 11,30));
+        project2.setWorkload(2);
+        project2.setDescription("Entwicklung von EAFC 25 für neues Spaß erlebnis");
+
+        //Define the behavior of the mocked ProjectService: return a list of projects when requested
+        when(projectService.getAllProjects()).thenReturn(Arrays.asList(project, project2));
+
+        //Act & Assert: Send GET request an expect a 200 Ok status and JSON response with the list of projects
+        mockMvc.perform(get("/api/project/all")
+                        .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$[0].id").value(1))
+                .andExpect(jsonPath("$[0].name").value("Skillmanagementsystem erstellen"))
+                .andExpect(jsonPath("$[0].startDate").value("2024-11-08"))
+                .andExpect(jsonPath("$[0].endDate").value("2024-11-20"))
+                .andExpect(jsonPath("$[0].workload").value(12))
+                .andExpect(jsonPath("$[0].description").value("Skillmanagementsystem erstellen für die Firma"))
+                .andExpect(jsonPath("$[1].id").value(2))
+                .andExpect(jsonPath("$[1].name").value("EAFC 25"))
+                .andExpect(jsonPath("$[1].startDate").value("2024-11-20"))
+                .andExpect(jsonPath("$[1].endDate").value("2024-11-30"))
+                .andExpect(jsonPath("$[1].workload").value(2))
+                .andExpect(jsonPath("$[1].description").value("Entwicklung von EAFC 25 für neues Spaß erlebnis"));
+    }
+
+    @Test
+    public void testGetProjectsByUserId() throws Exception {
+        // Arrange: Mock projects for a specific user
+        Project project1 = new Project();
+        project1.setId(1L);
+        project1.setName("Skill Management System");
+        project1.setStartDate(LocalDate.of(2024, 11, 8));
+        project1.setEndDate(LocalDate.of(2024, 11, 20));
+        project1.setWorkload(12);
+        project1.setDescription("Create a skill management system for the company");
+
+        Project project2 = new Project();
+        project2.setId(2L);
+        project2.setName("Project Management Tool");
+        project2.setStartDate(LocalDate.of(2024, 12, 1));
+        project2.setEndDate(LocalDate.of(2024, 12, 15));
+        project2.setWorkload(10);
+        project2.setDescription("Develop a project management tool");
+
+        Long userId = 123L;
+
+        // Mock the ProjectService to return projects for a specific user
+        when(projectService.getProjectsByUserId(userId)).thenReturn(Arrays.asList(project1, project2));
+
+        // Act & Assert: Send GET request and expect a 200 OK status with the correct JSON response
+        mockMvc.perform(get("/api/project/from-user")
+                        .param("userId", String.valueOf(userId))
+                        .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$[0].id").value(1))
+                .andExpect(jsonPath("$[0].name").value("Skill Management System"))
+                .andExpect(jsonPath("$[1].id").value(2))
+                .andExpect(jsonPath("$[1].name").value("Project Management Tool"));
+    }
+
+    @Test
+    public void testCreateProject() throws Exception {
+        // Arrange: Create a new project and set all required fields
+        Project savedProject = new Project();
+        savedProject.setId(1L); // ID setzen
+        savedProject.setName("New Project");
+        savedProject.setStartDate(LocalDate.of(2024, 11, 10));
+        savedProject.setEndDate(LocalDate.of(2024, 12, 10));
+        savedProject.setWorkload(15);
+        savedProject.setDescription("A new project for testing");
+
+        // Mocking the saveProject method to return this specific project
+        when(projectService.saveProject(any(Project.class))).thenReturn(savedProject);
+
+        // Act & Assert: Send POST request and check for 201 Created with JSON response
+        mockMvc.perform(post("/api/project")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content("{\"name\":\"New Project\",\"startDate\":\"2024-11-10\",\"endDate\":\"2024-12-10\",\"workload\":15,\"description\":\"A new project for testing\"}"))
+                .andExpect(status().isCreated())
+                .andExpect(jsonPath("$.id").value(1)) // Ensure the response JSON contains id = 1
+                .andExpect(jsonPath("$.name").value("New Project"))
+                .andExpect(jsonPath("$.workload").value(15))
+                .andExpect(jsonPath("$.description").value("A new project for testing"));
+    }
+
+    @Test
+    public void testUpdateProject() throws Exception {
+        // Arrange: Create an existing project
+        Project project = new Project();
+        project.setId(1L);
+        project.setName("Updated Project");
+        project.setStartDate(LocalDate.of(2024, 11, 10));
+        project.setEndDate(LocalDate.of(2024, 12, 10));
+        project.setWorkload(20);
+        project.setDescription("An updated project description");
+
+        // Mock the ProjectService to return the updated project
+        when(projectService.saveProject(project)).thenReturn(project);
+
+        // Act & Assert: Send PUT request and expect a 200 OK status with the updated project as JSON response
+        mockMvc.perform(put("/api/project")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content("{\"id\":1,\"name\":\"Updated Project\",\"startDate\":\"2024-11-10\",\"endDate\":\"2024-12-10\",\"workload\":20,\"description\":\"An updated project description\"}"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.id").value(1))
+                .andExpect(jsonPath("$.name").value("Updated Project"))
+                .andExpect(jsonPath("$.workload").value(20))
+                .andExpect(jsonPath("$.description").value("An updated project description"));
+    }
+
+    @Test
+    public void testDeleteProject() throws Exception {
+        // Arrange: Define the ID of the project to delete
+        Long projectId = 1L;
+
+        // No need to mock the delete method as it returns void, we just ensure no exception is thrown
+
+        // Act & Assert: Send DELETE request and expect a 204 No Content status
+        mockMvc.perform(delete("/api/project")
+                        .param("id", String.valueOf(projectId))
+                        .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isNoContent());
+    }
+}

src/test/java/com/maradona/backend/controllers/api/SecondarySkillControllerTest.java

@@ -0,0 +1,130 @@
+package com.maradona.backend.controllers.api;
+
+import com.maradona.backend.entities.SecondarySkill;
+import com.maradona.backend.services.SecondarySkillService;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+
+@WebMvcTest(SecondarySkillController.class)
+public class SecondarySkillControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private SecondarySkillService secondarySkillService;
+
+    @Test
+    public void testGetSecondarySkillById() throws Exception {
+        SecondarySkill skill = new SecondarySkill();
+        skill.setSsid(1L);
+        skill.setDescription("Java Programming");
+
+        when(secondarySkillService.getSecondarySkillById(1L)).thenReturn(Optional.of(skill));
+
+        mockMvc.perform(get("/api/secondary-skill")
+                .param("id", "1")
+                .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.ssid").value(1))
+                .andExpect(jsonPath("$.description").value("Java Programming"));
+    }
+
+    @Test
+    public void testGetAllSecondarySkills() throws Exception {
+        SecondarySkill skill1 = new SecondarySkill();
+        skill1.setSsid(1L);
+        skill1.setDescription("Java Programming");
+
+        SecondarySkill skill2 = new SecondarySkill();
+        skill2.setSsid(2L);
+        skill2.setDescription("Python Programming");
+
+        when(secondarySkillService.getAllSecondarySkills()).thenReturn(Arrays.asList(skill1, skill2));
+
+        mockMvc.perform(get("/api/secondary-skill/all")
+                .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$[1].ssid").value(1))
+                .andExpect(jsonPath("$[1].description").value("Java Programming"))
+                .andExpect(jsonPath("$[2].ssid").value(2))
+                .andExpect(jsonPath("$[2].description").value("Python Programming"));
+    }
+
+    @Test
+    public void testGetSecondarySkillsByPrimarySkillId() throws Exception {
+        SecondarySkill skill1 = new SecondarySkill();
+        skill1.setSsid(1L);
+        skill1.setDescription("Data Analysis");
+
+        SecondarySkill skill2 = new SecondarySkill();
+        skill2.setSsid(2L);
+        skill2.setDescription("Data Visualization");
+
+        when(secondarySkillService.getSecondarySkillsByPrimarySkillId(100L)).thenReturn(Arrays.asList(skill1, skill2));
+
+        mockMvc.perform(get("/api/secondary-skill/from-primary-skill")
+                .param("primarySkillId", "100")
+                .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$[1].ssid").value(1))
+                .andExpect(jsonPath("$[1].description").value("Data Analysis"))
+                .andExpect(jsonPath("$[2].ssid").value(2))
+                .andExpect(jsonPath("$[2].description").value("Data Visualization"));
+    }
+
+    @Test
+    public void testCreateSecondarySkill() throws Exception {
+        SecondarySkill skill = new SecondarySkill();
+        skill.setSsid(1L);
+        skill.setDescription("Machine Learning");
+
+        when(secondarySkillService.saveSecondarySkill(any(SecondarySkill.class))).thenReturn(skill);
+
+        mockMvc.perform(post("/api/secondary-skill")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content("{\"name\":\"Machine Learning\"}"))
+                .andExpect(status().isCreated())
+                .andExpect(jsonPath("$.ssid").value(1))
+                .andExpect(jsonPath("$.description").value("Machine Learning"));
+    }
+
+    @Test
+    public void testUpdateSecondarySkill() throws Exception {
+        SecondarySkill updatedSkill = new SecondarySkill();
+        updatedSkill.setSsid(1L);
+        updatedSkill.setDescription("Advanced Machine Learning");
+
+        when(secondarySkillService.saveSecondarySkill(any(SecondarySkill.class))).thenReturn(updatedSkill);
+
+        mockMvc.perform(put("/api/secondary-skill")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content("{\"ssid\":1,\"description\":\"Advanced Machine Learning\"}"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.ssid").value(1))
+                .andExpect(jsonPath("$.description").value("Advanced Machine Learning"));
+    }
+
+    @Test
+    public void testDeleteSecondarySkill() throws Exception {
+        Long skillId = 1L;
+
+        mockMvc.perform(delete("/api/secondary-skill")
+                .param("id", String.valueOf(skillId))
+                .contentType(MediaType.APPLICATION_JSON))
+                .andExpect(status().isNoContent());
+    }
+}