c8h4/beerbrawl
1
0
Fork 0
mirror of https://codeberg.org/beerbrawl/beerbrawl.git synced 2024-09-23 05:40:51 +02:00
Code Wiki Activity

Merge branch 'feature/#30/update-beerpong-table-for-tournament' into 'development'

Browse source 
feature/#30/update-beerpong-table-for-tournament

See merge request 2024ss-se-pr-group/24ss-se-pr-qse-11!35
This commit is contained in:
Moritz Kepplinger 2024-05-20 16:49:00 +00:00
parent 0c845c0415 27092ff1c0
commit 4e96073662
17 changed files with 747 additions and 18 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
backend/src/main/java/at/ac/tuwien/sepr/groupphase/backend/endpoint/BeerPongTableEndpoint.java
View file

@ -7,7 +7,10 @@ import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.security.access.annotation.Secured;
import org.springframework.security.core.Authentication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
@ -15,6 +18,7 @@ import org.springframework.web.bind.annotation.RestController;
import at.ac.tuwien.sepr.groupphase.backend.endpoint.dto.BeerPongTableDto;
import at.ac.tuwien.sepr.groupphase.backend.endpoint.dto.CreateBeerPongTableDto;
import at.ac.tuwien.sepr.groupphase.backend.endpoint.dto.UpdateBeerPongTableDto;
import at.ac.tuwien.sepr.groupphase.backend.endpoint.mapper.BeerPongTableMapper;
import at.ac.tuwien.sepr.groupphase.backend.service.BeerPongTableService;
import io.swagger.v3.oas.annotations.Operation;
@ -39,6 +43,15 @@ public class BeerPongTableEndpoint {
this.beerPongTableMapper = beerPongTableMapper;
}
@Secured("ROLE_USER")
@GetMapping(value = "{id}")
@Operation(summary = "Create a new beerpong table for a tournament", security = @SecurityRequirement(name = "apiKey"))
public BeerPongTableDto getBeerPongTable(@PathVariable(name = "id") Long beerPongTableId) {
LOG.info("GET /api/v1/beer-pong-tables/{}", beerPongTableId);
return beerPongTableMapper.entityToDto(beerPongTableService.findById(beerPongTableId));
}
@Secured("ROLE_USER")
@ResponseStatus(HttpStatus.CREATED)
@PostMapping
@ -50,4 +63,18 @@ public class BeerPongTableEndpoint {
return beerPongTableMapper.entityToDto(beerPongTableService.create(createDto, authentication.getName()));
}
@Secured("ROLE_USER")
@ResponseStatus(HttpStatus.OK)
@PutMapping(value = "{id}")
@Operation(summary = "Update an existing beerpong table for a tournament", security = @SecurityRequirement(name = "apiKey"))
public BeerPongTableDto updateBeerPongTable(
@PathVariable(name = "id") Long beerPongTableId,
@Valid @RequestBody UpdateBeerPongTableDto updateDto,
Authentication authentication) {
LOG.info("POST /api/v1/beer-pong-tables/{} body: {}", beerPongTableId, updateDto);
return beerPongTableMapper
.entityToDto(beerPongTableService.update(beerPongTableId, updateDto, authentication.getName()));
}
}

23
backend/src/main/java/at/ac/tuwien/sepr/groupphase/backend/endpoint/dto/UpdateBeerPongTableDto.java Normal file
View file

@ -0,0 +1,23 @@
package at.ac.tuwien.sepr.groupphase.backend.endpoint.dto;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Pattern;
import jakarta.validation.constraints.Size;
public class UpdateBeerPongTableDto {
@NotNull(message = "Name can't be null.")
@Size(max = 200, message = "Name can't be more than 200 characters long.")
@NotBlank(message = "Name can't be empty.")
@Pattern(regexp = "[\\w\\s\\.äÄöÖüÜ\\-,]*", message = "Name contains not allowed characters.")
private String name;
public String getName() {
return name;
}
public UpdateBeerPongTableDto setName(String name) {
this.name = name;
return this;
}
}

27
backend/src/main/java/at/ac/tuwien/sepr/groupphase/backend/service/BeerPongTableService.java
View file

@ -3,15 +3,38 @@ package at.ac.tuwien.sepr.groupphase.backend.service;
import org.springframework.security.access.AccessDeniedException;
import at.ac.tuwien.sepr.groupphase.backend.endpoint.dto.CreateBeerPongTableDto;
import at.ac.tuwien.sepr.groupphase.backend.endpoint.dto.UpdateBeerPongTableDto;
import at.ac.tuwien.sepr.groupphase.backend.entity.BeerPongTable;
import at.ac.tuwien.sepr.groupphase.backend.exception.NotFoundException;
public interface BeerPongTableService {
/**
* Loads a single beerpong table by its id.
*
* @param beerPongTableId beerpong table to load
* @return found beerpong table entity
*/
BeerPongTable findById(Long beerPongTableId) throws NotFoundException;
/**
* Create a single beerpong table entity for a tournament.
*
* @param beerPongTable to create
* @return created tournament entity
* @param beerPongTable to create
* @param currentUserName username of the current user, is used to check if user
* has access
* @return created beerpong table entity
*/
BeerPongTable create(CreateBeerPongTableDto beerPongTable, String currentUserName) throws AccessDeniedException;
/**
* Update a single beerpong table entity.
*
* @param beerPongTableId id of beerpong table to update
* @param beerPongTable to update
* @param currentUserName username of the current user, is used to check if user
* has access
* @return updated beerpong table entity
*/
BeerPongTable update(Long beerPongTableId, UpdateBeerPongTableDto beerPongTable, String currentUserName)
throws AccessDeniedException, NotFoundException;
}

43
backend/src/main/java/at/ac/tuwien/sepr/groupphase/backend/service/impl/BeerPongTableServiceImpl.java
View file

@ -8,8 +8,10 @@ import org.springframework.security.access.AccessDeniedException;
import org.springframework.stereotype.Service;
import at.ac.tuwien.sepr.groupphase.backend.endpoint.dto.CreateBeerPongTableDto;
import at.ac.tuwien.sepr.groupphase.backend.endpoint.dto.UpdateBeerPongTableDto;
import at.ac.tuwien.sepr.groupphase.backend.entity.BeerPongTable;
import at.ac.tuwien.sepr.groupphase.backend.exception.NotFoundException;
import at.ac.tuwien.sepr.groupphase.backend.exception.PreconditionFailedException;
import at.ac.tuwien.sepr.groupphase.backend.repository.BeerPongTableRepository;
import at.ac.tuwien.sepr.groupphase.backend.repository.TournamentRepository;
import at.ac.tuwien.sepr.groupphase.backend.service.BeerPongTableService;
@ -27,6 +29,14 @@ public class BeerPongTableServiceImpl implements BeerPongTableService {
this.tournamentRepository = tournamentRepository;
}
@Override
public BeerPongTable findById(Long beerPongTableId) throws NotFoundException {
LOGGER.debug("Get a beer pong table by its id {}", beerPongTableId);
return beerPongTableRepository.findById(beerPongTableId)
.orElseThrow(() -> new NotFoundException("No beerpong table found."));
}
@Override
public BeerPongTable create(CreateBeerPongTableDto beerPongTable, String currentUser) {
LOGGER.debug("Create new beer pong table {}", beerPongTable);
@ -36,7 +46,7 @@ public class BeerPongTableServiceImpl implements BeerPongTableService {
if (tournament.getOrganizer() == null || !tournament.getOrganizer().getUsername().equals(currentUser)) {
LOGGER.debug(
"Couldn't create beer pong table for tournament with id {}, because the user who started tried to create it isn't the same as the creator of the tournament.",
"Couldn't create beer pong table for tournament with id {}, because the user who started tried to create it isn't the same as the organizer of the tournament.",
beerPongTable.getTournamentId());
throw new AccessDeniedException("Current user isn't organizer of tournament.");
}
@ -44,9 +54,38 @@ public class BeerPongTableServiceImpl implements BeerPongTableService {
var entity = new BeerPongTable(beerPongTable.getName());
entity.setTournament(tournament);
beerPongTableRepository.saveAndFlush(entity);
beerPongTableRepository.save(entity);
return entity;
}
@Override
public BeerPongTable update(Long beerPongTableId, UpdateBeerPongTableDto beerPongTable, String currentUser) {
LOGGER.debug("Update new beer pong table {}", beerPongTable);
var entity = beerPongTableRepository.findById(beerPongTableId)
.orElseThrow(() -> new NotFoundException("Beerpong table not found."));
if (entity.getTournament() == null) {
LOGGER.debug(
"Couldn't update beer pong table with id {}, because it has no tournament assigned to it.",
beerPongTableId);
throw new PreconditionFailedException("Beer pong table has no tournament assigned.");
}
var tournament = tournamentRepository.findById(entity.getTournament().getId())
.orElseThrow(() -> new NotFoundException("Tournament not found."));
if (tournament.getOrganizer() == null || !tournament.getOrganizer().getUsername().equals(currentUser)) {
LOGGER.debug(
"Couldn't update beer pong table with id {}, because the user who started tried to update it isn't the same as the organizer of the tournament.",
beerPongTableId);
throw new AccessDeniedException("Current user isn't organizer of tournament.");
}
entity.setName(beerPongTable.getName());
beerPongTableRepository.save(entity);
return entity;
}
}

159
backend/src/test/java/at/ac/tuwien/sepr/groupphase/backend/integrationtest/BeerPongTableEndpointTest.java
View file

@ -3,10 +3,14 @@ package at.ac.tuwien.sepr.groupphase.backend.integrationtest;
import at.ac.tuwien.sepr.groupphase.backend.basetest.TestData;
import at.ac.tuwien.sepr.groupphase.backend.basetest.TestUserData;
import at.ac.tuwien.sepr.groupphase.backend.config.properties.SecurityProperties;
import at.ac.tuwien.sepr.groupphase.backend.datagenerator.TestDataGenerator;
import at.ac.tuwien.sepr.groupphase.backend.endpoint.dto.BeerPongTableDto;
import at.ac.tuwien.sepr.groupphase.backend.endpoint.dto.CreateBeerPongTableDto;
import at.ac.tuwien.sepr.groupphase.backend.endpoint.dto.UpdateBeerPongTableDto;
import at.ac.tuwien.sepr.groupphase.backend.entity.ApplicationUser;
import at.ac.tuwien.sepr.groupphase.backend.entity.BeerPongTable;
import at.ac.tuwien.sepr.groupphase.backend.entity.Tournament;
import at.ac.tuwien.sepr.groupphase.backend.repository.BeerPongTableRepository;
import at.ac.tuwien.sepr.groupphase.backend.repository.UserRepository;
import at.ac.tuwien.sepr.groupphase.backend.security.JwtTokenizer;
import at.ac.tuwien.sepr.groupphase.backend.service.TournamentService;
@ -27,7 +31,9 @@ import org.springframework.test.web.servlet.MockMvc;
import java.time.LocalDateTime;
import static org.junit.jupiter.api.Assertions.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
@ExtendWith(SpringExtension.class)
@ -51,6 +57,52 @@ public class BeerPongTableEndpointTest extends TestUserData implements TestData
private TournamentService tournamentService;
@Autowired
private UserRepository userRepository;
@Autowired
private BeerPongTableRepository beerPongTableRepository;
@Test
public void getSingleBeerPongTableById() throws Exception {
// setup
var tournament = new Tournament();
tournament.setName("TEST_TOURNAMENT");
tournament.setRegistrationEnd(LocalDateTime.now().plusDays(1));
tournament.setMaxParticipants(64l);
tournament = tournamentService.create(tournament, TestDataGenerator.TEST_USER);
var beerPongTable = new BeerPongTable("TEST");
beerPongTable.setTournament(tournament);
beerPongTableRepository.save(beerPongTable);
var mvcResult = this.mockMvc
.perform(get(String.format("%s/%d", BEER_PONG_TABLE_BASE_URI, beerPongTable.getId()))
.header(securityProperties.getAuthHeader(),
jwtTokenizer.getAuthToken(TestDataGenerator.TEST_USER, TEST_USER_ROLES)))
.andDo(print())
.andReturn();
MockHttpServletResponse response = mvcResult.getResponse();
var dtoRes = objectMapper.readValue(response.getContentAsString(),
BeerPongTableDto.class);
assertAll(
() -> assertEquals(HttpStatus.OK.value(), response.getStatus()),
() -> assertNotNull(dtoRes),
() -> assertEquals(beerPongTable.getId(), dtoRes.id()),
() -> assertEquals(beerPongTable.getName(), dtoRes.name()),
() -> assertEquals(beerPongTable.getTournament().getId(), dtoRes.tournamentId()));
}
@Test
public void getSingleBeerPongTableThatDoesntExistById() throws Exception {
var mvcResult = this.mockMvc.perform(get(String.format("%s/%d", BEER_PONG_TABLE_BASE_URI, -1))
.header(securityProperties.getAuthHeader(),
jwtTokenizer.getAuthToken(TestDataGenerator.TEST_USER, TEST_USER_ROLES)))
.andDo(print())
.andReturn();
MockHttpServletResponse response = mvcResult.getResponse();
assertEquals(HttpStatus.NOT_FOUND.value(), response.getStatus());
}
@Test
public void createNewBeerPongTableForExistingTournamentThatWasCreatedByTheCurrentUser() throws Exception {
@ -69,7 +121,8 @@ public class BeerPongTableEndpointTest extends TestUserData implements TestData
tableDto.setTournamentId(tournament.getId());
var mvcResult = this.mockMvc.perform(post(BEER_PONG_TABLE_BASE_URI)
.header(securityProperties.getAuthHeader(), jwtTokenizer.getAuthToken(user.getUsername(), TEST_USER_ROLES))
.header(securityProperties.getAuthHeader(),
jwtTokenizer.getAuthToken(user.getUsername(), TEST_USER_ROLES))
.contentType(MediaType.APPLICATION_JSON)
.content(objectMapper.writeValueAsString(tableDto)))
.andDo(print())
@ -132,4 +185,108 @@ public class BeerPongTableEndpointTest extends TestUserData implements TestData
assertEquals(HttpStatus.NOT_FOUND.value(), response.getStatus());
}
@Test
public void updateBeerPongTableForExistingTournamentThatWasCreatedByTheCurrentUser() throws Exception {
// setup
var tournament = new Tournament();
tournament.setName("TEST_TOURNAMENT");
tournament.setRegistrationEnd(LocalDateTime.now().plusDays(1));
tournament.setMaxParticipants(64l);
tournament = tournamentService.create(tournament, TestDataGenerator.TEST_USER);
var beerPongTable = new BeerPongTable("TEST");
beerPongTable.setTournament(tournament);
beerPongTableRepository.save(beerPongTable);
var tableDto = new UpdateBeerPongTableDto();
tableDto.setName("TEST_NAME");
var mvcResult = this.mockMvc
.perform(put(String.format("%s/%d", BEER_PONG_TABLE_BASE_URI, beerPongTable.getId()))
.header(securityProperties.getAuthHeader(),
jwtTokenizer.getAuthToken(TestDataGenerator.TEST_USER, TEST_USER_ROLES))
.contentType(MediaType.APPLICATION_JSON)
.content(objectMapper.writeValueAsString(tableDto)))
.andDo(print())
.andReturn();
MockHttpServletResponse response = mvcResult.getResponse();
var dtoRes = objectMapper.readValue(response.getContentAsString(),
BeerPongTableDto.class);
assertAll(
() -> assertEquals(HttpStatus.OK.value(), response.getStatus()),
() -> assertEquals(MediaType.APPLICATION_JSON_VALUE,
response.getContentType()),
() -> assertEquals(dtoRes.name(), tableDto.getName()));
}
@Test
public void updateBeerPongTableForExistingTournamentThatWasntCreatedByTheCurrentUser() throws Exception {
// setup
var tournament = new Tournament();
tournament.setName("TEST_TOURNAMENT");
tournament.setRegistrationEnd(LocalDateTime.now().plusDays(1));
tournament.setMaxParticipants(64l);
tournament = tournamentService.create(tournament, TestDataGenerator.TEST_USER);
var beerPongTable = new BeerPongTable("TEST");
beerPongTable.setTournament(tournament);
beerPongTableRepository.save(beerPongTable);
var tableDto = new UpdateBeerPongTableDto();
tableDto.setName("TEST_NAME");
var mvcResult = this.mockMvc
.perform(put(String.format("%s/%d", BEER_PONG_TABLE_BASE_URI, beerPongTable.getId()))
.header(securityProperties.getAuthHeader(),
jwtTokenizer.getAuthToken(TestDataGenerator.TEST_USER + "_", TEST_USER_ROLES))
.contentType(MediaType.APPLICATION_JSON)
.content(objectMapper.writeValueAsString(tableDto)))
.andDo(print())
.andReturn();
MockHttpServletResponse response = mvcResult.getResponse();
assertEquals(HttpStatus.FORBIDDEN.value(), response.getStatus());
}
@Test
public void updateNonExistantBeerPongTable() throws Exception {
var tableDto = new UpdateBeerPongTableDto();
tableDto.setName("TEST_NAME");
var mvcResult = this.mockMvc
.perform(put(String.format("%s/%d", BEER_PONG_TABLE_BASE_URI, -1))
.header(securityProperties.getAuthHeader(),
jwtTokenizer.getAuthToken(TestDataGenerator.TEST_USER + "_", TEST_USER_ROLES))
.contentType(MediaType.APPLICATION_JSON)
.content(objectMapper.writeValueAsString(tableDto)))
.andDo(print())
.andReturn();
MockHttpServletResponse response = mvcResult.getResponse();
assertEquals(HttpStatus.NOT_FOUND.value(), response.getStatus());
}
@Test
public void tryToUpdateABeerPongTableThatHasNoTournamentAssigned() throws Exception {
var beerPongTable = new BeerPongTable("TEST");
beerPongTableRepository.save(beerPongTable);
var tableDto = new UpdateBeerPongTableDto();
tableDto.setName("TEST_NAME");
var mvcResult = this.mockMvc
.perform(put(String.format("%s/%d", BEER_PONG_TABLE_BASE_URI, beerPongTable.getId()))
.header(securityProperties.getAuthHeader(),
jwtTokenizer.getAuthToken(TestDataGenerator.TEST_USER, TEST_USER_ROLES))
.contentType(MediaType.APPLICATION_JSON)
.content(objectMapper.writeValueAsString(tableDto)))
.andDo(print())
.andReturn();
MockHttpServletResponse response = mvcResult.getResponse();
assertEquals(HttpStatus.BAD_REQUEST.value(), response.getStatus());
}
}

108
backend/src/test/java/at/ac/tuwien/sepr/groupphase/backend/unittests/BeerPongTableServiceTest.java
View file

@ -20,10 +20,12 @@ import org.springframework.transaction.annotation.Transactional;
import at.ac.tuwien.sepr.groupphase.backend.basetest.TestUserData;
import at.ac.tuwien.sepr.groupphase.backend.datagenerator.TestDataGenerator;
import at.ac.tuwien.sepr.groupphase.backend.endpoint.dto.CreateBeerPongTableDto;
import at.ac.tuwien.sepr.groupphase.backend.entity.ApplicationUser;
import at.ac.tuwien.sepr.groupphase.backend.endpoint.dto.UpdateBeerPongTableDto;
import at.ac.tuwien.sepr.groupphase.backend.entity.BeerPongTable;
import at.ac.tuwien.sepr.groupphase.backend.entity.Tournament;
import at.ac.tuwien.sepr.groupphase.backend.exception.NotFoundException;
import at.ac.tuwien.sepr.groupphase.backend.repository.UserRepository;
import at.ac.tuwien.sepr.groupphase.backend.exception.PreconditionFailedException;
import at.ac.tuwien.sepr.groupphase.backend.repository.BeerPongTableRepository;
import at.ac.tuwien.sepr.groupphase.backend.service.BeerPongTableService;
import at.ac.tuwien.sepr.groupphase.backend.service.TournamentService;
@ -35,9 +37,37 @@ public class BeerPongTableServiceTest extends TestUserData {
@Autowired
private TournamentService tournamentService;
@Autowired
private UserRepository userRepository;
@Autowired
private BeerPongTableService beerPongTableService;
@Autowired
private BeerPongTableRepository beerPongTableRepository;
@Test
public void getSingleBeerPongTableById() {
// setup
var tournament = new Tournament();
tournament.setName("TEST_TOURNAMENT");
tournament.setRegistrationEnd(LocalDateTime.now().plusDays(1));
tournament.setMaxParticipants(64l);
tournament = tournamentService.create(tournament, TestDataGenerator.TEST_USER);
var beerPongTable = new BeerPongTable("TEST");
beerPongTable.setTournament(tournament);
beerPongTableRepository.save(beerPongTable);
var table = assertDoesNotThrow(
() -> beerPongTableService.findById(beerPongTable.getId()));
assertAll(
() -> assertNotNull(table),
() -> assertEquals(table.getName(), table.getName()),
() -> assertEquals(table.getTournament().getId(), table.getTournament().getId()));
}
@Test
public void getSingleBeerPongTableThatDoesntExistById() {
assertThrows(NotFoundException.class,
() -> beerPongTableService.findById(-1L));
}
@Test
public void createNewBeerPongTableForExistingTournamentThatWasCreatedByTheCurrentUser() {
@ -63,9 +93,6 @@ public class BeerPongTableServiceTest extends TestUserData {
@Test
public void createNewBeerPongTableForExistingTournamentThatWasntCreatedByTheCurrentUser() {
// setup
var user = new ApplicationUser("TestUser", "Password", false);
userRepository.save(user);
var tournament = new Tournament();
tournament.setName("TEST_TOURNAMENT");
tournament.setRegistrationEnd(LocalDateTime.now().plusDays(1));
@ -86,6 +113,71 @@ public class BeerPongTableServiceTest extends TestUserData {
tableDto.setName("TEST_NAME");
tableDto.setTournamentId(-1l);
assertThrows(NotFoundException.class, () -> beerPongTableService.create(tableDto, "TestUser"));
assertThrows(NotFoundException.class, () -> beerPongTableService.create(tableDto, TestDataGenerator.TEST_USER));
}
@Test
public void updateBeerPongTableForExistingTournamentThatWasCreatedByTheCurrentUser() {
// setup
var tournament = new Tournament();
tournament.setName("TEST_TOURNAMENT");
tournament.setRegistrationEnd(LocalDateTime.now().plusDays(1));
tournament.setMaxParticipants(64l);
tournament = tournamentService.create(tournament, TestDataGenerator.TEST_USER);
var beerPongTable = new BeerPongTable("TEST");
beerPongTable.setTournament(tournament);
beerPongTableRepository.save(beerPongTable);
var tableDto = new UpdateBeerPongTableDto();
tableDto.setName("TEST_NAME");
var table = assertDoesNotThrow(
() -> beerPongTableService.update(beerPongTable.getId(), tableDto, TestDataGenerator.TEST_USER));
assertAll(
() -> assertNotNull(table),
() -> assertEquals(table.getName(), tableDto.getName()));
}
@Test
public void updateBeerPongTableForExistingTournamentThatWasntCreatedByTheCurrentUser() {
// setup
var tournament = new Tournament();
tournament.setName("TEST_TOURNAMENT");
tournament.setRegistrationEnd(LocalDateTime.now().plusDays(1));
tournament.setMaxParticipants(64l);
tournament = tournamentService.create(tournament, TestDataGenerator.TEST_USER);
var beerPongTable = new BeerPongTable("TEST");
beerPongTable.setTournament(tournament);
beerPongTableRepository.save(beerPongTable);
var tableDto = new UpdateBeerPongTableDto();
tableDto.setName("TEST_NAME");
assertThrows(AccessDeniedException.class,
() -> beerPongTableService.update(beerPongTable.getId(), tableDto, TestDataGenerator.TEST_USER + "_"));
}
@Test
public void updateNonExistantBeerPongTable() {
var tableDto = new UpdateBeerPongTableDto();
tableDto.setName("TEST_NAME");
assertThrows(NotFoundException.class,
() -> beerPongTableService.update(-1L, tableDto, TestDataGenerator.TEST_USER));
}
@Test
public void tryToUpdateABeerPongTableThatHasNoTournamentAssigned() {
var beerPongTable = new BeerPongTable("TEST");
beerPongTableRepository.save(beerPongTable);
var tableDto = new UpdateBeerPongTableDto();
tableDto.setName("TEST_NAME");
assertThrows(PreconditionFailedException.class,
() -> beerPongTableService.update(beerPongTable.getId(), tableDto, TestDataGenerator.TEST_USER));
}
}

1
frontend/openapi-generated/.openapi-generator/FILES
View file

@ -25,6 +25,7 @@ model/tournamentDto.ts
model/tournamentListDto.ts
model/tournamentQualificationMatchDto.ts
model/tournamentQualificationMatchParticipantDto.ts
model/updateBeerPongTableDto.ts
model/userDetailDto.ts
model/userLoginDto.ts
param.ts

144
frontend/openapi-generated/api/beerPongTableEndpoint.service.ts
View file

@ -22,6 +22,8 @@ import { Observable } from 'rxjs';
import { BeerPongTableDto } from '../model/beerPongTableDto';
// @ts-ignore
import { CreateBeerPongTableDto } from '../model/createBeerPongTableDto';
// @ts-ignore
import { UpdateBeerPongTableDto } from '../model/updateBeerPongTableDto';
// @ts-ignore
import { BASE_PATH, COLLECTION_FORMATS } from '../variables';
@ -167,4 +169,146 @@ export class BeerPongTableEndpointService {
);
}
/**
* Create a new beerpong table for a tournament
* @param id
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @param reportProgress flag to report request and response progress.
*/
public getBeerPongTable(id: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<BeerPongTableDto>;
public getBeerPongTable(id: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<BeerPongTableDto>>;
public getBeerPongTable(id: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<BeerPongTableDto>>;
public getBeerPongTable(id: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
if (id === null || id === undefined) {
throw new Error('Required parameter id was null or undefined when calling getBeerPongTable.');
}
let localVarHeaders = this.defaultHeaders;
let localVarHttpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;
if (localVarHttpHeaderAcceptSelected === undefined) {
// to determine the Accept header
const httpHeaderAccepts: string[] = [
'application/json'
];
localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
}
if (localVarHttpHeaderAcceptSelected !== undefined) {
localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
}
let localVarHttpContext: HttpContext | undefined = options && options.context;
if (localVarHttpContext === undefined) {
localVarHttpContext = new HttpContext();
}
let localVarTransferCache: boolean | undefined = options && options.transferCache;
if (localVarTransferCache === undefined) {
localVarTransferCache = true;
}
let responseType_: 'text' | 'json' | 'blob' = 'json';
if (localVarHttpHeaderAcceptSelected) {
if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
responseType_ = 'text';
} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
responseType_ = 'json';
} else {
responseType_ = 'blob';
}
}
let localVarPath = `/api/v1/beer-pong-tables/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int64"})}`;
return this.httpClient.request<BeerPongTableDto>('get', `${this.configuration.basePath}${localVarPath}`,
{
context: localVarHttpContext,
responseType: <any>responseType_,
withCredentials: this.configuration.withCredentials,
headers: localVarHeaders,
observe: observe,
transferCache: localVarTransferCache,
reportProgress: reportProgress
}
);
}
/**
* Update an existing beerpong table for a tournament
* @param id
* @param updateBeerPongTableDto
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @param reportProgress flag to report request and response progress.
*/
public updateBeerPongTable(id: number, updateBeerPongTableDto: UpdateBeerPongTableDto, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<BeerPongTableDto>;
public updateBeerPongTable(id: number, updateBeerPongTableDto: UpdateBeerPongTableDto, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<BeerPongTableDto>>;
public updateBeerPongTable(id: number, updateBeerPongTableDto: UpdateBeerPongTableDto, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<BeerPongTableDto>>;
public updateBeerPongTable(id: number, updateBeerPongTableDto: UpdateBeerPongTableDto, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
if (id === null || id === undefined) {
throw new Error('Required parameter id was null or undefined when calling updateBeerPongTable.');
}
if (updateBeerPongTableDto === null || updateBeerPongTableDto === undefined) {
throw new Error('Required parameter updateBeerPongTableDto was null or undefined when calling updateBeerPongTable.');
}
let localVarHeaders = this.defaultHeaders;
let localVarHttpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;
if (localVarHttpHeaderAcceptSelected === undefined) {
// to determine the Accept header
const httpHeaderAccepts: string[] = [
'application/json'
];
localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
}
if (localVarHttpHeaderAcceptSelected !== undefined) {
localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
}
let localVarHttpContext: HttpContext | undefined = options && options.context;
if (localVarHttpContext === undefined) {
localVarHttpContext = new HttpContext();
}
let localVarTransferCache: boolean | undefined = options && options.transferCache;
if (localVarTransferCache === undefined) {
localVarTransferCache = true;
}
// to determine the Content-Type header
const consumes: string[] = [
'application/json'
];
const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
if (httpContentTypeSelected !== undefined) {
localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
}
let responseType_: 'text' | 'json' | 'blob' = 'json';
if (localVarHttpHeaderAcceptSelected) {
if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
responseType_ = 'text';
} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
responseType_ = 'json';
} else {
responseType_ = 'blob';
}
}
let localVarPath = `/api/v1/beer-pong-tables/${this.configuration.encodeParam({name: "id", value: id, in: "path", style: "simple", explode: false, dataType: "number", dataFormat: "int64"})}`;
return this.httpClient.request<BeerPongTableDto>('put', `${this.configuration.basePath}${localVarPath}`,
{
context: localVarHttpContext,
body: updateBeerPongTableDto,
responseType: <any>responseType_,
withCredentials: this.configuration.withCredentials,
headers: localVarHeaders,
observe: observe,
transferCache: localVarTransferCache,
reportProgress: reportProgress
}
);
}
}

1
frontend/openapi-generated/model/models.ts
View file

@ -10,5 +10,6 @@ export * from './tournamentDto';
export * from './tournamentListDto';
export * from './tournamentQualificationMatchDto';
export * from './tournamentQualificationMatchParticipantDto';
export * from './updateBeerPongTableDto';
export * from './userDetailDto';
export * from './userLoginDto';

17
frontend/openapi-generated/model/updateBeerPongTableDto.ts Normal file
View file

@ -0,0 +1,17 @@
/**
* OpenAPI definition
* No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
*
* The version of the OpenAPI document: v0
*
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
export interface UpdateBeerPongTableDto {
name: string;
}

15
frontend/src/app/app-routing.module.ts
View file

@ -12,6 +12,7 @@ import { AuthGuard } from './guards/auth.guard';
import { AuthLayoutComponent } from './layouts/auth-layout/auth-layout.component';
import { MainLayoutComponent } from './layouts/main-layout/main-layout.component';
import { BeerPongTableCreateComponent } from './components/beer-pong-table-create/beer-pong-table-create.component';
import { BeerPongTableUpdateComponent } from './components/beer-pong-table-update/beer-pong-table-update.component';
const routes: Routes = [
{
@ -41,10 +42,18 @@ const routes: Routes = [
},
],
},
{ path: 'details/:username', component: UserDetailComponent },
{
path: 'beer-pong-tables/create',
component: BeerPongTableCreateComponent,
path: 'beer-pong-tables',
children: [
{
path: 'create',
component: BeerPongTableCreateComponent,
},
{
path: ':beerPongTableId/update',
component: BeerPongTableUpdateComponent,
},
],
},
],
},

4
frontend/src/app/components/beer-pong-table-create/beer-pong-table-create.component.html
View file

@ -49,7 +49,9 @@
</mat-form-field>
</mat-card-content>
<mat-card-actions>
<button mat-button [disabled]="this.beerPongTableForm.disabled">Abort</button>
<a mat-button [disabled]="this.beerPongTableForm.disabled" [routerLink]="'/beer-pong-tables'">
Abort
</a>
<button
mat-button
color="primary"

3
frontend/src/app/components/beer-pong-table-create/beer-pong-table-create.component.ts
View file

@ -19,8 +19,8 @@ import {
import { Router } from '@angular/router';
import { MatSnackBar } from '@angular/material/snack-bar';
import { HttpErrorResponse } from '@angular/common/http';
import { CreateBeerPongTableDto } from 'openapi-generated/model/createBeerPongTableDto';
import { MatSelectModule } from '@angular/material/select';
import { RouterModule } from '@angular/router';
@Component({
selector: 'beer-pong-table-create',
@ -36,6 +36,7 @@ import { MatSelectModule } from '@angular/material/select';
MatSelectModule,
FormsModule,
ReactiveFormsModule,
RouterModule,
],
providers: [],
templateUrl: './beer-pong-table-create.component.html',

51
frontend/src/app/components/beer-pong-table-update/beer-pong-table-update.component.html Normal file
View file

@ -0,0 +1,51 @@
<form [formGroup]="beerPongTableForm" (ngSubmit)="updateBeerPongTable()">
<mat-card>
<mat-card-header>
<mat-card-title>Update Beer Pong Table</mat-card-title>
</mat-card-header>
<mat-card-content>
<mat-form-field appearance="outline">
<mat-label>Name</mat-label>
<input matInput type="text" formControlName="name" name="name" />
@if (
beerPongTableForm.controls.name.invalid &&
beerPongTableForm.controls.name.errors?.['required']
) {
<mat-error>Name is required.</mat-error>
}
@if (
beerPongTableForm.controls.name.invalid &&
beerPongTableForm.controls.name.errors?.['pattern']
) {
<mat-error> Name contains charachters that aren't allowed.</mat-error>
}
@if (
beerPongTableForm.controls.name.invalid &&
beerPongTableForm.controls.name.errors?.['minlength']
) {
<mat-error> Name needs to be at least one character long.</mat-error>
}
@if (
beerPongTableForm.controls.name.invalid &&
beerPongTableForm.controls.name.errors?.['maxlength']
) {
<mat-error> Name can't be more thant 200 characters.</mat-error>
}
</mat-form-field>
</mat-card-content>
<mat-card-actions>
<a mat-button [disabled]="this.beerPongTableForm.disabled" [routerLink]="'/beer-pong-tables'">
Abort
</a>
<button
mat-button
color="primary"
type="submit"
[disabled]="this.beerPongTableForm.disabled"
id="update-beer-pong-table"
>
Update
</button>
</mat-card-actions>
</mat-card>
</form>

13
frontend/src/app/components/beer-pong-table-update/beer-pong-table-update.component.scss Normal file
View file

@ -0,0 +1,13 @@
mat-card-content {
display: flex;
flex-direction: column;
& mat-form-field {
margin-bottom: 16px;
}
& .form-actions {
display: flex;
justify-content: flex-end;
}
}

22
frontend/src/app/components/beer-pong-table-update/beer-pong-table-update.component.spec.ts Normal file
View file

@ -0,0 +1,22 @@
import { ComponentFixture, TestBed } from '@angular/core/testing';
import { BeerPongTableCreateComponent } from './beer-pong-table-create.component';
describe('BeerPongTableCreateComponent', () => {
let component: BeerPongTableCreateComponent;
let fixture: ComponentFixture<BeerPongTableCreateComponent>;
beforeEach(async () => {
await TestBed.configureTestingModule({
imports: [BeerPongTableCreateComponent],
}).compileComponents();
fixture = TestBed.createComponent(BeerPongTableCreateComponent);
component = fixture.componentInstance;
fixture.detectChanges();
});
it('should create', () => {
expect(component).toBeTruthy();
});
});

107
frontend/src/app/components/beer-pong-table-update/beer-pong-table-update.component.ts Normal file
View file

@ -0,0 +1,107 @@
import { Component, OnInit } from '@angular/core';
import { MatFormFieldModule } from '@angular/material/form-field';
import { MatIconModule } from '@angular/material/icon';
import { MatInputModule } from '@angular/material/input';
import {
FormControl,
FormGroup,
FormsModule,
ReactiveFormsModule,
Validators,
} from '@angular/forms';
import { MatButtonModule } from '@angular/material/button';
import { MatCardModule } from '@angular/material/card';
import { BeerPongTableEndpointService } from 'openapi-generated';
import { ActivatedRoute, Router } from '@angular/router';
import { MatSnackBar } from '@angular/material/snack-bar';
import { HttpErrorResponse } from '@angular/common/http';
import { MatSelectModule } from '@angular/material/select';
import { RouterModule } from '@angular/router';
@Component({
selector: 'beer-pong-table-update',
standalone: true,
imports: [
MatFormFieldModule,
MatInputModule,
MatFormFieldModule,
MatInputModule,
MatIconModule,
MatButtonModule,
MatCardModule,
MatSelectModule,
FormsModule,
ReactiveFormsModule,
RouterModule,
],
providers: [],
templateUrl: './beer-pong-table-update.component.html',
styleUrl: './beer-pong-table-update.component.scss',
})
export class BeerPongTableUpdateComponent implements OnInit {
beerPongTableForm = new FormGroup({
name: new FormControl('', [
Validators.required,
Validators.minLength(1),
Validators.maxLength(200),
Validators.pattern(/^[\w\s.äÄöÖüÜ\-,]*$/),
]),
});
constructor(
private client: BeerPongTableEndpointService,
private router: Router,
private route: ActivatedRoute,
private snackBar: MatSnackBar,
) {}
ngOnInit() {
this.loadBeerPongTable();
}
private loadBeerPongTable() {
this.route.params.subscribe(params =>
this.client.getBeerPongTable(params.beerPongTableId).subscribe({
next: data => {
this.beerPongTableForm.setValue({ name: data.name ?? '' });
},
error: () => {
this.snackBar.open('Failed to load beer pong table', 'Close', { duration: 3000 });
},
}),
);
}
saveBeerPongTable() {
this.beerPongTableForm.disable();
this.route.params.subscribe(params =>
this.client
.updateBeerPongTable(params.beerPongTableId, {
name: this.beerPongTableForm.controls.name.value ?? '',
})
.subscribe({
next: () => {
this.snackBar.open('Successfully updated beer pong table', 'Close', {
duration: 3000,
});
this.router.navigate(['/beer-pong-tables']);
},
error: async (er: HttpErrorResponse) => {
this.snackBar.open(
`There was a problem creating the beer pong table: ${await er.error.text()}`,
'Close',
{ duration: 3000 },
);
this.beerPongTableForm.enable();
},
}),
);
}
updateBeerPongTable() {
if (this.beerPongTableForm.valid) {
this.saveBeerPongTable();
}
}
}