Feature/519 team management

backend/src/main/java/ch/puzzle/okr/controller/OrganisationController.java

@@ -0,0 +1,50 @@
+package ch.puzzle.okr.controller;
+
+import ch.puzzle.okr.dto.OrganisationDto;
+import ch.puzzle.okr.mapper.OrganisationMapper;
+import ch.puzzle.okr.service.authorization.OrganisationAuthorizationService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("api/v1/organisations")
+public class OrganisationController {
+    private final OrganisationAuthorizationService organisationAuthorizationService;
+    private final OrganisationMapper organisationMapper;
+
+    public OrganisationController(OrganisationAuthorizationService organisationAuthorizationService,
+            OrganisationMapper organisationMapper) {
+        this.organisationAuthorizationService = organisationAuthorizationService;
+        this.organisationMapper = organisationMapper;
+    }
+
+    @Operation(summary = "Get all active Organisations", description = "Get all active Organisations")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "Returned all active Organisations", content = {
+                    @Content(mediaType = "application/json", schema = @Schema(implementation = OrganisationDto.class)) }),
+            @ApiResponse(responseCode = "401", description = "Not authorized to read organisations", content = @Content) })
+    @GetMapping
+    public ResponseEntity<List<OrganisationDto>> getActiveOrganisations() {
+        return ResponseEntity.status(HttpStatus.OK).body(
+                organisationAuthorizationService.getEntities().stream().map(this.organisationMapper::toDto).toList());
+    }
+
+    @Operation(summary = "Get Organisations of team", description = "Get all Organisations of team")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "Returned all Organisations of team", content = {
+                    @Content(mediaType = "application/json", schema = @Schema(implementation = OrganisationDto.class)) }),
+            @ApiResponse(responseCode = "401", description = "Not authorized to read organisations of team", content = @Content) })
+    @GetMapping("/{id}")
+    public ResponseEntity<List<OrganisationDto>> getOrganisationsByTeam(@PathVariable Long id) {
+        return ResponseEntity.status(HttpStatus.OK).body(organisationAuthorizationService.getEntitiesByTeam(id).stream()
+                .map(this.organisationMapper::toDto).toList());
+    }
+}

backend/src/main/java/ch/puzzle/okr/controller/OverviewController.java

@@ -1,6 +1,8 @@
 package ch.puzzle.okr.controller;
 
+import ch.puzzle.okr.dto.overview.DashboardDto;
 import ch.puzzle.okr.dto.overview.OverviewDto;
+import ch.puzzle.okr.mapper.DashboardMapper;
 import ch.puzzle.okr.mapper.OverviewMapper;
 import ch.puzzle.okr.service.authorization.OverviewAuthorizationService;
 import io.swagger.v3.oas.annotations.Operation;
@@ -21,12 +23,14 @@
 @RequestMapping("api/v2/overview")
 public class OverviewController {
     private final OverviewMapper overviewMapper;
+    private final DashboardMapper dashboardMapper;
     private final OverviewAuthorizationService overviewAuthorizationService;
 
-    public OverviewController(OverviewMapper overviewMapper,
-            OverviewAuthorizationService overviewAuthorizationService) {
+    public OverviewController(OverviewMapper overviewMapper, OverviewAuthorizationService overviewAuthorizationService,
+            DashboardMapper dashboardMapper) {
         this.overviewMapper = overviewMapper;
         this.overviewAuthorizationService = overviewAuthorizationService;
+        this.dashboardMapper = dashboardMapper;
     }
 
     @Operation(summary = "Get all teams and their objectives", description = "Get a List of teams with their objectives")
@@ -37,11 +41,14 @@ public OverviewController(OverviewMapper overviewMapper,
             @ApiResponse(responseCode = "401", description = "Not authorized to read teams with their objectives", content = @Content),
             @ApiResponse(responseCode = "404", description = "The quarter or one of the teams were not found", content = @Content) })
     @GetMapping("")
-    public ResponseEntity<List<OverviewDto>> getOverview(
+    public ResponseEntity<DashboardDto> getOverview(
             @RequestParam(required = false, defaultValue = "", name = "team") List<Long> teamFilter,
             @RequestParam(required = false, defaultValue = "", name = "quarter") Long quarterFilter,
             @RequestParam(required = false, defaultValue = "", name = "objectiveQuery") String objectiveQuery) {
-        return ResponseEntity.status(HttpStatus.OK).body(overviewMapper
-                .toDto(overviewAuthorizationService.getFilteredOverview(quarterFilter, teamFilter, objectiveQuery)));
+        boolean hasWriteAllAccess = overviewAuthorizationService.hasWriteAllAccess();
+        return ResponseEntity.status(HttpStatus.OK)
+                .body(dashboardMapper.toDto(overviewMapper.toDto(
+                        overviewAuthorizationService.getFilteredOverview(quarterFilter, teamFilter, objectiveQuery)),
+                        hasWriteAllAccess));
     }
 }

backend/src/main/java/ch/puzzle/okr/controller/TeamController.java

@@ -2,27 +2,30 @@
 
 import ch.puzzle.okr.dto.TeamDto;
 import ch.puzzle.okr.mapper.TeamMapper;
-import ch.puzzle.okr.service.business.TeamBusinessService;
+import ch.puzzle.okr.models.Team;
+import ch.puzzle.okr.service.authorization.TeamAuthorizationService;
 import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.media.Content;
 import io.swagger.v3.oas.annotations.media.Schema;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.responses.ApiResponses;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
 
+import static org.springframework.http.HttpStatus.OK;
+
 @RestController
 @RequestMapping("api/v2/teams")
 public class TeamController {
-    private final TeamBusinessService teamBusinessService;
+    private final TeamAuthorizationService teamAuthorizationService;
     private final TeamMapper teamMapper;
 
-    public TeamController(TeamBusinessService teamBusinessService, TeamMapper teamMapper) {
-        this.teamBusinessService = teamBusinessService;
+    public TeamController(TeamAuthorizationService teamAuthorizationService, TeamMapper teamMapper) {
+        this.teamAuthorizationService = teamAuthorizationService;
         this.teamMapper = teamMapper;
     }
 
@@ -32,6 +35,44 @@ public TeamController(TeamBusinessService teamBusinessService, TeamMapper teamMa
                     @Content(mediaType = "application/json", schema = @Schema(implementation = TeamDto.class)) }), })
     @GetMapping
     public List<TeamDto> getAllTeams(@RequestParam(value = "quarterId", required = false) Long quarterId) {
-        return teamBusinessService.getAllTeams().stream().map(team -> teamMapper.toDto(team, quarterId)).toList();
+        return teamAuthorizationService.getEntities().stream().map(team -> teamMapper.toDto(team, quarterId)).toList();
+    }
+
+    @Operation(summary = "Create Team", description = "Create a new Team")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "201", description = "Created new Team", content = {
+                    @Content(mediaType = "application/json", schema = @Schema(implementation = TeamDto.class)) }),
+            @ApiResponse(responseCode = "400", description = "Can't create new Team, not allowed to give an ID", content = @Content),
+            @ApiResponse(responseCode = "401", description = "Not authorized to create a Team", content = @Content) })
+    @PostMapping
+    public ResponseEntity<TeamDto> createTeam(
+            @io.swagger.v3.oas.annotations.parameters.RequestBody(description = "The Team as json to create a new Team.", required = true) @RequestBody TeamDto teamDto) {
+        Team createdTeam = teamAuthorizationService.createEntity(teamMapper.toTeam(teamDto));
+        return ResponseEntity.status(HttpStatus.CREATED).body(teamMapper.toDto(createdTeam, null));
+    }
+
+    @Operation(summary = "Update Team", description = "Update a Team by ID.")
+    @ApiResponses(value = {
+            @ApiResponse(responseCode = "200", description = "Updated Team in db.", content = {
+                    @Content(mediaType = "application/json", schema = @Schema(allOf = { TeamDto.class })) }),
+            @ApiResponse(responseCode = "401", description = "Not authorized to update a Team", content = @Content),
+            @ApiResponse(responseCode = "404", description = "Did not find a Team with a specified ID to update.", content = @Content),
+            @ApiResponse(responseCode = "422", description = "Can't update Team since Team was updated or deleted by another user.", content = @Content) })
+    @PutMapping("/{id}")
+    public ResponseEntity<TeamDto> updateTeam(
+            @Parameter(description = "The ID for updating a Team.", required = true) @PathVariable long id,
+            @RequestBody TeamDto teamDto) {
+        Team updatedTeam = teamAuthorizationService.updateEntity(teamMapper.toTeam(teamDto), id);
+        return ResponseEntity.status(OK).body(teamMapper.toDto(updatedTeam, null));
+    }
+
+    @Operation(summary = "Delete Team by ID", description = "Delete Team by ID")
+    @ApiResponses(value = { @ApiResponse(responseCode = "200", description = "Deleted Team by ID"),
+            @ApiResponse(responseCode = "401", description = "Not authorized to delete an Team", content = @Content),
+            @ApiResponse(responseCode = "404", description = "Did not find the Team with requested ID") })
+    @DeleteMapping("/{id}")
+    public void deleteTeamById(
+            @Parameter(description = "The ID of an Team to delete it.", required = true) @PathVariable long id) {
+        teamAuthorizationService.deleteEntity(id);
     }
 }

backend/src/main/java/ch/puzzle/okr/dto/OrganisationDto.java

@@ -0,0 +1,6 @@
+package ch.puzzle.okr.dto;
+
+import ch.puzzle.okr.models.OrganisationState;
+
+public record OrganisationDto(Long id, int version, String orgName, OrganisationState state) {
+}

backend/src/main/java/ch/puzzle/okr/dto/TeamDto.java

@@ -1,4 +1,6 @@
 package ch.puzzle.okr.dto;
 
-public record TeamDto(Long id, String name, Integer activeObjectives) {
+import java.util.List;
+
+public record TeamDto(Long id, String name, Integer activeObjectives, List<OrganisationDto> organisations) {
 }

backend/src/main/java/ch/puzzle/okr/dto/overview/DashboardDto.java

@@ -0,0 +1,6 @@
+package ch.puzzle.okr.dto.overview;
+
+import java.util.List;
+
+public record DashboardDto(Boolean adminAccess, List<OverviewDto> overviews) {
+}

backend/src/main/java/ch/puzzle/okr/mapper/DashboardMapper.java

@@ -0,0 +1,15 @@
+package ch.puzzle.okr.mapper;
+
+import ch.puzzle.okr.dto.overview.DashboardDto;
+import ch.puzzle.okr.dto.overview.OverviewDto;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+public class DashboardMapper {
+
+    public DashboardDto toDto(List<OverviewDto> overviews, Boolean adminAccess) {
+        return new DashboardDto(adminAccess, overviews);
+    }
+}

backend/src/main/java/ch/puzzle/okr/mapper/OrganisationMapper.java

@@ -0,0 +1,19 @@
+package ch.puzzle.okr.mapper;
+
+import ch.puzzle.okr.dto.OrganisationDto;
+import ch.puzzle.okr.models.Organisation;
+import org.springframework.stereotype.Component;
+
+@Component
+public class OrganisationMapper {
+
+    public OrganisationDto toDto(Organisation organisation) {
+        return new OrganisationDto(organisation.getId(), organisation.getVersion(), organisation.getOrgName(),
+                organisation.getState());
+    }
+
+    public Organisation toOrganisation(OrganisationDto organisationDto) {
+        return Organisation.Builder.builder().withId(organisationDto.id()).withVersion(organisationDto.version())
+                .withOrgName(organisationDto.orgName()).withState(organisationDto.state()).build();
+    }
+}

backend/src/main/java/ch/puzzle/okr/mapper/TeamMapper.java

@@ -1,29 +1,41 @@
 package ch.puzzle.okr.mapper;
 
+import ch.puzzle.okr.dto.OrganisationDto;
 import ch.puzzle.okr.dto.TeamDto;
+import ch.puzzle.okr.models.Organisation;
 import ch.puzzle.okr.models.Team;
 import ch.puzzle.okr.service.business.QuarterBusinessService;
 import ch.puzzle.okr.service.business.TeamBusinessService;
 import org.springframework.stereotype.Component;
 
+import java.util.List;
+
 @Component
 public class TeamMapper {
 
     private final TeamBusinessService teamBusinessService;
     private final QuarterBusinessService quarterBusinessService;
+    private final OrganisationMapper organisationMapper;
 
-    public TeamMapper(TeamBusinessService teamBusinessService, QuarterBusinessService quarterBusinessService) {
+    public TeamMapper(TeamBusinessService teamBusinessService, QuarterBusinessService quarterBusinessService,
+            OrganisationMapper organisationMapper) {
         this.teamBusinessService = teamBusinessService;
         this.quarterBusinessService = quarterBusinessService;
+        this.organisationMapper = organisationMapper;
     }
 
     public TeamDto toDto(Team team, Long quarterId) {
         long chosenQuarterId = quarterId == null ? quarterBusinessService.getCurrentQuarter().getId() : quarterId;
         Integer activeObjectives = teamBusinessService.activeObjectivesAmountOfTeam(team, chosenQuarterId);
-        return new TeamDto(team.getId(), team.getName(), activeObjectives);
+        List<OrganisationDto> organisationDTOs = team.getAuthorizationOrganisation().stream()
+                .map(organisationMapper::toDto).toList();
+        return new TeamDto(team.getId(), team.getName(), activeObjectives, organisationDTOs);
     }
 
     public Team toTeam(TeamDto teamDto) {
-        return Team.Builder.builder().withId(teamDto.id()).withName(teamDto.name()).build();
+        List<Organisation> organisations = teamDto.organisations().stream().map(organisationMapper::toOrganisation)
+                .toList();
+        return Team.Builder.builder().withId(teamDto.id()).withName(teamDto.name())
+                .withAuthorizationOrganisation(organisations).build();
     }
 }

backend/src/main/java/ch/puzzle/okr/models/Organisation.java

@@ -20,7 +20,7 @@ public class Organisation {
     @NotBlank
     private String orgName;
 
-    @ManyToMany(mappedBy = "authorizationOrganisation")
+    @ManyToMany(mappedBy = "authorizationOrganisation", fetch = FetchType.EAGER)
     private List<Team> teams;
 
     @Enumerated(EnumType.STRING)

backend/src/main/java/ch/puzzle/okr/models/Team.java

@@ -18,7 +18,7 @@ public class Team {
     @Size(min = 2, max = 250, message = "Attribute name must have size between 2 and 250 characters when saving team")
     private String name;
 
-    @ManyToMany
+    @ManyToMany(fetch = FetchType.EAGER)
     @JoinTable(name = "team_organisation", joinColumns = @JoinColumn(name = "team_id"), inverseJoinColumns = @JoinColumn(name = "organisation_id"))
     private List<Organisation> authorizationOrganisation;
 

backend/src/main/java/ch/puzzle/okr/repository/ObjectiveRepository.java

@@ -6,8 +6,12 @@
 import org.springframework.data.repository.CrudRepository;
 import org.springframework.stereotype.Repository;
 
+import java.util.List;
+
 @Repository
 public interface ObjectiveRepository extends CrudRepository<Objective, Long> {
 
     Integer countByTeamAndQuarter(Team team, Quarter quarter);
+
+    List<Objective> findObjectivesByTeamId(Long id);
 }

backend/src/main/java/ch/puzzle/okr/repository/OrganisationRepository.java

@@ -1,11 +1,21 @@
 package ch.puzzle.okr.repository;
 
 import ch.puzzle.okr.models.Organisation;
+import ch.puzzle.okr.models.OrganisationState;
+import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.CrudRepository;
+import org.springframework.data.repository.query.Param;
+
+import java.util.List;
 
 public interface OrganisationRepository extends CrudRepository<Organisation, Long> {
 
     Organisation findByOrgName(String name);
 
     boolean existsOrganisationByOrgName(String name);
+
+    @Query(value = "SELECT * FROM organisation LEFT JOIN team_organisation ON organisation.id=team_organisation.organisation_id WHERE team_organisation.team_id = :id", nativeQuery = true)
+    List<Organisation> findOrganisationsByTeamId(@Param("id") Long id);
+
+    List<Organisation> findOrganisationsByState(OrganisationState state);
 }

backend/src/main/java/ch/puzzle/okr/repository/TeamRepository.java

@@ -15,4 +15,6 @@ public interface TeamRepository extends CrudRepository<Team, Long> {
             where o.org_name in (:organisationNames)
             """, nativeQuery = true)
     List<Long> findTeamIdsByOrganisationNames(@Param("organisationNames") List<String> organisationNames);
+
+    List<Team> findTeamsByName(String name);
 }

backend/src/main/java/ch/puzzle/okr/service/authorization/AuthorizationRegistrationService.java

@@ -45,20 +45,10 @@ public AuthorizationUser registerAuthorizationUser(User user, Jwt token) {
     }
 
     private List<Long> getTeamIds(List<String> organisationNames) {
-        List<Long> teamIds = teamPersistenceService.findTeamIdsByOrganisationNames(organisationNames);
-        if (teamIds.isEmpty()) {
-            throw new ResponseStatusException(UNAUTHORIZED,
-                    "no team found for given organisations " + organisationNames);
-        }
-        return teamIds;
+        return teamPersistenceService.findTeamIdsByOrganisationNames(organisationNames);
     }
 
     private List<Long> getFirstLevelTeamIds() {
-        List<Long> teamIds = teamPersistenceService.findTeamIdsByOrganisationName(firstLevelOrganisationName);
-        if (teamIds.isEmpty()) {
-            throw new ResponseStatusException(UNAUTHORIZED,
-                    "no team found for given organisation " + firstLevelOrganisationName);
-        }
-        return teamIds;
+        return teamPersistenceService.findTeamIdsByOrganisationName(firstLevelOrganisationName);
     }
 }