RaidBuilder/RaidBuilderAPI
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Person tab working

Browse Source
This commit is contained in:
Mattrixwv
2025-03-08 13:26:59 -05:00
parent 3e0996c432
commit 868daeb517
17 changed files with 579 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
db/1.0.0/12. createPerson.sql Normal file
View File

@@ -0,0 +1,16 @@
CREATE TABLE raid_builder.person(
person_id uuid PRIMARY KEY,
raid_group_id uuid REFERENCES raid_builder.raid_group(raid_group_id) NOT NULL,
person_name text NOT NULL,
discord_id text,
--Auditing
modified_by uuid,
modified_date timestamptz,
created_by uuid NOT NULL,
created_date timestamptz NOT NULL
);
CREATE INDEX idx_person_raid_group_id ON raid_builder.person(raid_group_id);
GRANT ALL ON TABLE raid_builder.person TO raid_builder;

21
db/1.0.0/13. createPersonCharacter.sql Normal file
View File

@@ -0,0 +1,21 @@
CREATE TABLE raid_builder.person_character(
person_character_id uuid PRIMARY KEY,
person_id uuid REFERENCES raid_builder.person(person_id) NOT NULL,
game_class_id uuid REFERENCES raid_builder.game_class(game_class_id) NOT NULL,
character_name text NOT NULL,
character_rating int,
character_comments text,
--Auditing
modified_by uuid,
modified_date timestamptz,
created_by uuid,
created_date timestamptz NOT NULL
);
CREATE INDEX idx_person_character_person_id ON raid_builder.person_character(person_id);
CREATE INDEX idx_person_character_game_class_id ON raid_builder.person_character(game_class_id);
CREATE INDEX idx_person_character_character_name ON raid_builder.person_character(character_name);
CREATE INDEX idx_person_character_character_rading ON raid_builder.person_character(character_rating);
GRANT ALL ON TABLE raid_builder.person_character TO raid_builder;

29
src/main/java/com/mattrixwv/raidbuilder/controller/IconController.java
View File

@@ -4,6 +4,7 @@ package com.mattrixwv.raidbuilder.controller;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.UUID;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.ResponseEntity;
@@ -13,7 +14,10 @@ import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.mattrixwv.raidbuilder.annotation.AccountAuthorization;
import com.mattrixwv.raidbuilder.entity.GameClass;
import com.mattrixwv.raidbuilder.service.GameClassService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@@ -21,12 +25,15 @@ import lombok.extern.slf4j.Slf4j;
@Slf4j
@RestController
@RequestMapping("/icons")
@RequiredArgsConstructor
public class IconController{
private final GameClassService gameClassService;
//Properties
@Value("${uploadFileDirectory}")
private String uploadFileDirectory;
@GetMapping("/gameIcons/{gameIconName}")
@GetMapping("/game/{gameIconName}")
@AccountAuthorization(permissions = {})
public ResponseEntity<byte[]> getGameIcons(@PathVariable("gameIconName") String gameIconName) throws IOException{
log.info("Getting game icon {}", gameIconName);
@@ -38,7 +45,7 @@ public class IconController{
return ResponseEntity.ok().body(resource);
}
@GetMapping("/raidGroupIcons/{raidGroupIconName}")
@GetMapping("/raidGroup/{raidGroupIconName}")
@AccountAuthorization(permissions = {})
public ResponseEntity<byte[]> getRaidGroupIcons(@PathVariable("raidGroupIconName") String raidGroupIconName) throws IOException{
log.info("Getting raid group icon {}", raidGroupIconName);
@@ -50,7 +57,7 @@ public class IconController{
return ResponseEntity.ok().body(resource);
}
@GetMapping("/gameClassIcons/{gameClassIconName}")
@GetMapping("/gameClass/{gameClassIconName}")
@AccountAuthorization(permissions = {})
public ResponseEntity<byte[]> getGameClassIcons(@PathVariable("gameClassIconName") String gameClassIconName) throws IOException{
log.info("Getting game class icon {}", gameClassIconName);
@@ -59,6 +66,22 @@ public class IconController{
byte[] resource = Files.readAllBytes(Path.of(uploadFileDirectory + "/gameClassIcons/" + gameClassIconName));
return ResponseEntity.ok().body(resource);
}
@GetMapping("/gameClass/id/{gameClassId}")
@AccountAuthorization(permissions = {})
public ResponseEntity<byte[]> getGameClassIcons(@PathVariable("gameClassId") UUID gameClassId) throws IOException{
log.info("Getting game class icon {}", gameClassId);
GameClass gameClass = gameClassService.getById(gameClassId);
byte[] resource = null;
if((gameClass != null) && (gameClass.getGameClassIcon() != null)){
resource = Files.readAllBytes(Path.of(uploadFileDirectory + "/gameClassIcons/" + gameClass.getGameClassIcon()));
}
return ResponseEntity.ok().body(resource);
}
}

81
src/main/java/com/mattrixwv/raidbuilder/controller/PersonCharacterController.java Normal file
View File

@@ -0,0 +1,81 @@
package com.mattrixwv.raidbuilder.controller;
import java.util.List;
import java.util.UUID;
import org.springframework.web.bind.annotation.DeleteMapping;
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.RestController;
import com.mattrixwv.raidbuilder.annotation.AccountAuthorization;
import com.mattrixwv.raidbuilder.annotation.RaidGroupAuthorization;
import com.mattrixwv.raidbuilder.entity.PersonCharacter;
import com.mattrixwv.raidbuilder.service.PersonCharacterService;
import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.AccountPermissionType;
import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.RaidGroupPermissionType;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@RestController
@RequestMapping("/raidGroup/{raidGroupId}/person/{personId}/character")
@RequiredArgsConstructor
public class PersonCharacterController{
private final PersonCharacterService personCharacterService;
@GetMapping
@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
@RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN, RaidGroupPermissionType.LEADER, RaidGroupPermissionType.RAIDER})
public List<PersonCharacter> getPersonCharactersForPerson(@PathVariable("raidGroupId") UUID raidGroupId, @PathVariable("personId") UUID personId){
log.info("Getting person characters for person {}", personId);
return personCharacterService.getByPersonId(personId);
}
@PostMapping
@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
@RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN, RaidGroupPermissionType.LEADER})
public PersonCharacter createPersonCharacter(@PathVariable("raidGroupId") UUID raidGroupId, @PathVariable("personId") UUID personId, @RequestBody PersonCharacter personCharacter){
log.info("Creating person character {} for person {}", personCharacter.getCharacterName(), personId);
personCharacter.setPersonId(personId);
personCharacter = personCharacterService.createPersonCharacter(personCharacter);
return personCharacter;
}
@PutMapping("/{characterId}")
@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
@RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN, RaidGroupPermissionType.LEADER})
public PersonCharacter updatePersonCharacter(@PathVariable("raidGroupId") UUID raidGroupId, @PathVariable("personId") UUID personId, @PathVariable("characterId") UUID characterId, @RequestBody PersonCharacter personCharacter){
log.info("Updating person character {} for person {}", personCharacter.getCharacterName(), personId);
personCharacter.setPersonCharacterId(characterId);
personCharacter.setPersonId(personId);
personCharacter = personCharacterService.updatePersonCharacter(personCharacter);
return personCharacter;
}
@DeleteMapping("/{characterId}")
@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
@RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN, RaidGroupPermissionType.LEADER})
public void deletePersonCharacter(@PathVariable("raidGroupId") UUID raidGroupId, @PathVariable("personId") UUID personId, @PathVariable("characterId") UUID characterId){
log.info("Deleting person character {} for person {}", characterId, personId);
personCharacterService.deletePersonCharacter(characterId);
}
}

149
src/main/java/com/mattrixwv/raidbuilder/controller/PersonController.java Normal file
View File

@@ -0,0 +1,149 @@
package com.mattrixwv.raidbuilder.controller;
import java.util.List;
import java.util.UUID;
import org.springframework.web.bind.annotation.DeleteMapping;
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.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.mattrixwv.raidbuilder.annotation.AccountAuthorization;
import com.mattrixwv.raidbuilder.annotation.RaidGroupAuthorization;
import com.mattrixwv.raidbuilder.entity.Person;
import com.mattrixwv.raidbuilder.service.PersonService;
import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.AccountPermissionType;
import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.RaidGroupPermissionType;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@RestController
@RequestMapping("/raidGroup/{raidGroupId}/person")
@RequiredArgsConstructor
public class PersonController{
private final ObjectMapper mapper;
private final PersonService personService;
@GetMapping
@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
@RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN, RaidGroupPermissionType.LEADER, RaidGroupPermissionType.RAIDER})
public List<Person> getPeople(@PathVariable("raidGroupId") UUID raidGroupId, @RequestParam("page") int page, @RequestParam("pageSize") int pageSize, @RequestParam(name = "searchTerm", required = false) String searchTerm){
log.info("Getting people for raid group: {} page {} of size {} with search term {}", raidGroupId, page, pageSize, searchTerm);
List<Person> people;
if(searchTerm == null){
people = personService.getPeopleByRaidGroup(raidGroupId, page, pageSize);
}
else{
people = personService.getPeopleByRaidGroup(raidGroupId, page, pageSize, searchTerm);
}
return people;
}
@GetMapping("/count")
@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
@RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN, RaidGroupPermissionType.LEADER, RaidGroupPermissionType.RAIDER})
public ObjectNode getPeopleCount(@PathVariable("raidGroupId") UUID raidGroupId, @RequestParam(name = "searchTerm", required = false) String searchTerm){
log.info("Getting people count for raid group {}", raidGroupId);
long peopleCount;
if(searchTerm == null){
peopleCount = personService.getPeopleCountByRaidGroup(raidGroupId);
}
else{
peopleCount = personService.getPeopleCountByRaidGroup(raidGroupId, searchTerm);
}
ObjectNode countNode = mapper.createObjectNode();
countNode.put("count", peopleCount);
countNode.put("status", "success");
return countNode;
}
@GetMapping("/{personId}")
@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
@RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN, RaidGroupPermissionType.LEADER, RaidGroupPermissionType.RAIDER})
public Person getPerson(@PathVariable("raidGroupId") UUID raidGroupId, @PathVariable("personId") UUID personId){
log.info("Getting person for raid group {}", raidGroupId);
Person person = personService.getPerson(personId, raidGroupId);
return person;
}
@PostMapping
@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
@RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN, RaidGroupPermissionType.LEADER})
public Person createPerson(@PathVariable("raidGroupId") UUID raidGroupId, @RequestBody Person person){
log.info("Creating person for raid group {}", raidGroupId);
person.setRaidGroupId(raidGroupId);
person = personService.createPerson(person);
return person;
}
@PutMapping("/{personId}")
@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
@RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN, RaidGroupPermissionType.LEADER})
public Person updatePerson(@PathVariable("raidGroupId") UUID raidGroupId, @PathVariable("personId") UUID personId, @RequestBody Person person){
log.info("Updating person for raid group {}", raidGroupId);
person.setPersonId(personId);
person.setRaidGroupId(raidGroupId);
person = personService.updatePerson(person);
return person;
}
@DeleteMapping("/{personId}")
@AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER})
@RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN, RaidGroupPermissionType.LEADER})
public ObjectNode deletePerson(@PathVariable("raidGroupId") UUID raidGroupId, @PathVariable("personId") UUID personId){
log.info("Deleting person for raid group {}", raidGroupId);
Person person = personService.getPerson(personId, raidGroupId);
ObjectNode returnNode = mapper.createObjectNode();
if(person == null){
ArrayNode errorsNode = mapper.createArrayNode();
errorsNode.add("Person not found");
returnNode.set("errors", errorsNode);
returnNode.put("status", "error");
}
else{
personService.deletePerson(personId);
returnNode.put("status", "success");
}
return returnNode;
}
}

33
src/main/java/com/mattrixwv/raidbuilder/entity/Person.java Normal file
View File

@@ -0,0 +1,33 @@
package com.mattrixwv.raidbuilder.entity;
import java.util.UUID;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
@Entity
@Table(name = "person", schema = "raid_builder")
@Data
@EqualsAndHashCode(callSuper = false)
@NoArgsConstructor
public class Person extends AuditableEntity{
@Id
@GeneratedValue(strategy = GenerationType.UUID)
@Column(name = "person_id")
private UUID personId;
@Column(name = "raid_group_id")
private UUID raidGroupId;
@Column(name = "person_name")
private String personName;
@Column(name = "discord_id")
private String discordId;
}

37
src/main/java/com/mattrixwv/raidbuilder/entity/PersonCharacter.java Normal file
View File

@@ -0,0 +1,37 @@
package com.mattrixwv.raidbuilder.entity;
import java.util.UUID;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
@Entity
@Table(name = "person_character", schema = "raid_builder")
@Data
@EqualsAndHashCode(callSuper = false)
@NoArgsConstructor
public class PersonCharacter extends AuditableEntity{
@Id
@Column(name = "person_character_id")
@GeneratedValue(strategy = GenerationType.UUID)
private UUID personCharacterId;
@Column(name = "person_id")
private UUID personId;
@Column(name = "game_class_id")
private UUID gameClassId;
@Column(name = "character_name")
private String characterName;
@Column(name = "character_rating")
private int characterRating;
@Column(name = "character_comments")
private String characterComments;
}

5
src/main/java/com/mattrixwv/raidbuilder/repository/person/PersonCustomRepository.java Normal file
View File

@@ -0,0 +1,5 @@
package com.mattrixwv.raidbuilder.repository.person;
public interface PersonCustomRepository{
}

25
src/main/java/com/mattrixwv/raidbuilder/repository/person/PersonRepository.java Normal file
View File

@@ -0,0 +1,25 @@
package com.mattrixwv.raidbuilder.repository.person;
import java.util.List;
import java.util.UUID;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.jpa.repository.JpaRepository;
import com.mattrixwv.raidbuilder.entity.Person;
public interface PersonRepository extends PersonCustomRepository, JpaRepository<Person, UUID>{
public void deleteAllByRaidGroupId(UUID raidGroupId);
public void deleteAllByRaidGroupIdIn(Iterable<UUID> raidGroupIds);
public List<Person> findAllByRaidGroupId(UUID raidGroupId);
public List<Person> findAllByRaidGroupIdIn(Iterable<UUID> raidGroupIds);
public List<Person> findAllByRaidGroupId(UUID raidGroupId, PageRequest pageRequest);
public List<Person> findAllByRaidGroupIdAndPersonNameContainingIgnoreCase(UUID raidGroupId, String searchTerm, PageRequest pageRequest);
public long countByRaidGroupId(UUID raidGroupId);
public long countByRaidGroupIdAndPersonNameContainingIgnoreCase(UUID raidGroupId, String searchTerm);
}

9
src/main/java/com/mattrixwv/raidbuilder/repository/person/PersonRepositoryImpl.java Normal file
View File

@@ -0,0 +1,9 @@
package com.mattrixwv.raidbuilder.repository.person;
import org.springframework.stereotype.Repository;
@Repository
public class PersonRepositoryImpl implements PersonCustomRepository{
}

5
src/main/java/com/mattrixwv/raidbuilder/repository/person_character/PersonCharacterCustomRepository.java Normal file
View File

@@ -0,0 +1,5 @@
package com.mattrixwv.raidbuilder.repository.person_character;
public interface PersonCharacterCustomRepository{
}

19
src/main/java/com/mattrixwv/raidbuilder/repository/person_character/PersonCharacterRepository.java Normal file
View File

@@ -0,0 +1,19 @@
package com.mattrixwv.raidbuilder.repository.person_character;
import java.util.List;
import java.util.UUID;
import org.springframework.data.jpa.repository.JpaRepository;
import com.mattrixwv.raidbuilder.entity.PersonCharacter;
public interface PersonCharacterRepository extends PersonCharacterCustomRepository, JpaRepository<PersonCharacter, UUID>{
public void deleteAllByPersonId(UUID personId);
public void deleteAllByPersonIdIn(Iterable<UUID> personIds);
public PersonCharacter findByPersonCharacterId(UUID personCharacterId);
public List<PersonCharacter> findAllByPersonId(UUID personId);
}

9
src/main/java/com/mattrixwv/raidbuilder/repository/person_character/PersonCharacterRepositoryImpl.java Normal file
View File

@@ -0,0 +1,9 @@
package com.mattrixwv.raidbuilder.repository.person_character;
import org.springframework.stereotype.Repository;
@Repository
public class PersonCharacterRepositoryImpl implements PersonCharacterCustomRepository{
}

4
src/main/java/com/mattrixwv/raidbuilder/service/GameClassService.java
View File

@@ -111,6 +111,10 @@ public class GameClassService{
//Read
public GameClass getById(UUID gameClassId){
return gameClassRepository.findById(gameClassId).orElse(null);
}
public List<GameClass> getByGameId(UUID gameId, int page, int pageSize){
return gameClassRepository.findAllByGameId(gameId, PageRequest.of(page, pageSize, Sort.by("gameClassName").ascending()));
}

50
src/main/java/com/mattrixwv/raidbuilder/service/PersonCharacterService.java Normal file
View File

@@ -0,0 +1,50 @@
package com.mattrixwv.raidbuilder.service;
import java.util.List;
import java.util.UUID;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.mattrixwv.raidbuilder.entity.PersonCharacter;
import com.mattrixwv.raidbuilder.repository.person_character.PersonCharacterRepository;
import lombok.RequiredArgsConstructor;
@Service
@Transactional(rollbackFor = Exception.class)
@RequiredArgsConstructor
public class PersonCharacterService{
private final PersonCharacterRepository personCharacterRepository;
//Write
public PersonCharacter createPersonCharacter(PersonCharacter personCharacter){
return personCharacterRepository.save(personCharacter);
}
public PersonCharacter updatePersonCharacter(PersonCharacter personCharacter){
return personCharacterRepository.save(personCharacter);
}
public void deletePersonCharacter(UUID personCharacterId){
personCharacterRepository.deleteById(personCharacterId);
}
public void deletePersonCharactersByPersonId(UUID personId){
personCharacterRepository.deleteAllByPersonId(personId);
}
public void deletePersonCharactersByPersonIds(Iterable<UUID> personIds){
personCharacterRepository.deleteAllByPersonIdIn(personIds);
}
//Read
public List<PersonCharacter> getByPersonId(UUID personId){
return personCharacterRepository.findAllByPersonId(personId);
}
}

87
src/main/java/com/mattrixwv/raidbuilder/service/PersonService.java Normal file
View File

@@ -0,0 +1,87 @@
package com.mattrixwv.raidbuilder.service;
import java.util.List;
import java.util.UUID;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.mattrixwv.raidbuilder.entity.Person;
import com.mattrixwv.raidbuilder.repository.person.PersonRepository;
import lombok.RequiredArgsConstructor;
@Service
@Transactional(rollbackFor = Exception.class)
@RequiredArgsConstructor
public class PersonService{
private final PersonRepository personRepository;
//Related services
private final PersonCharacterService personCharacterService;
//Write
public Person createPerson(Person person){
return personRepository.save(person);
}
public Person updatePerson(Person person){
return personRepository.save(person);
}
public void deletePerson(UUID personId){
personCharacterService.deletePersonCharactersByPersonId(personId);
personRepository.deleteById(personId);
}
public void deleteByRaidGroupId(UUID raidGroupId){
List<UUID> personIds = personRepository.findAllByRaidGroupId(raidGroupId).stream().map(Person::getPersonId).toList();
personCharacterService.deletePersonCharactersByPersonIds(personIds);
personRepository.deleteAllByRaidGroupId(raidGroupId);
}
public void deleteByRaidGroupIds(Iterable<UUID> raidGroupIds){
List<UUID> personIds = personRepository.findAllByRaidGroupIdIn(raidGroupIds).stream().map(Person::getPersonId).toList();
personCharacterService.deletePersonCharactersByPersonIds(personIds);
personRepository.deleteAllByRaidGroupIdIn(raidGroupIds);
}
//Read
public Person getPerson(UUID personId, UUID raidGroupId){
Person person = personRepository.findById(personId).orElse(null);
if(person != null && person.getRaidGroupId().equals(raidGroupId)){
return person;
}
else{
return null;
}
}
public List<Person> getPeopleByRaidGroup(UUID raidGroupId, int page, int pageSize){
return personRepository.findAllByRaidGroupId(raidGroupId, PageRequest.of(page, pageSize, Sort.by("personName").ascending()));
}
public List<Person> getPeopleByRaidGroup(UUID raidGroupId, int page, int pageSize, String searchTerm){
return personRepository.findAllByRaidGroupIdAndPersonNameContainingIgnoreCase(
raidGroupId,
searchTerm,
PageRequest.of(page, pageSize, Sort.by("personName").ascending())
);
}
public long getPeopleCountByRaidGroup(UUID raidGroupId){
return personRepository.countByRaidGroupId(raidGroupId);
}
public long getPeopleCountByRaidGroup(UUID raidGroupId, String searchTerm){
return personRepository.countByRaidGroupIdAndPersonNameContainingIgnoreCase(raidGroupId, searchTerm);
}
}

3
src/main/java/com/mattrixwv/raidbuilder/service/RaidGroupService.java
View File

@@ -32,6 +32,7 @@ import lombok.extern.slf4j.Slf4j;
public class RaidGroupService{
private final RaidGroupRepository raidGroupRepository;
//Related Services
private final PersonService personService;
private final RaidGroupCalendarEventService raidGroupCalendarEventService;
private final RaidGroupPermissionService raidGroupPermissionService;
//Values
@@ -109,6 +110,7 @@ public class RaidGroupService{
existingFile.delete();
}
}
personService.deleteByRaidGroupId(raidGroupId);
raidGroupCalendarEventService.deleteByRaidGroupId(raidGroupId);
raidGroupPermissionService.deleteByRaidGroupId(raidGroupId);
raidGroupRepository.flush();
@@ -128,6 +130,7 @@ public class RaidGroupService{
}
}
List<UUID> raidGroupIds = raidGroups.stream().map(RaidGroup::getRaidGroupId).toList();
personService.deleteByRaidGroupIds(raidGroupIds);
raidGroupCalendarEventService.deleteByRaidGroupIds(raidGroupIds);
raidGroupPermissionService.deleteByRaidGroupIds(raidGroupIds);
raidGroupRepository.flush();