From b618d571433f62c4121681367d3ce628c5b238c8 Mon Sep 17 00:00:00 2001 From: Mattrixwv Date: Sun, 6 Apr 2025 21:59:06 -0400 Subject: [PATCH] Add validation to utils --- .../controller/AccountController.java | 125 ++++++++++-- .../controller/AccountTutorialController.java | 1 + .../controller/AuthenticationController.java | 50 +---- .../controller/CalendarController.java | 102 ++++++++-- .../controller/ClassGroupController.java | 57 +++++- .../controller/GameClassController.java | 52 ++++- .../controller/GameController.java | 73 +++++-- .../controller/PersonCharacterController.java | 63 +++++- .../controller/PersonController.java | 40 +++- .../controller/RaidGroupController.java | 49 +++-- .../RaidGroupRequestController.java | 52 ++++- .../controller/RaidInstanceController.java | 57 +++++- .../controller/RaidLayoutController.java | 52 ++++- .../repository/person/PersonRepository.java | 1 + .../PersonCharacterRepository.java | 2 +- .../raid_group/RaidGroupRepository.java | 2 + .../raid_layout/RaidLayoutRepository.java | 1 + .../service/GameCalendarEventService.java | 12 +- .../service/PersonCharacterService.java | 8 + .../raidbuilder/service/PersonService.java | 5 + .../RaidGroupCalendarEventService.java | 4 + .../service/RaidGroupRequestService.java | 4 + .../raidbuilder/service/RaidGroupService.java | 5 + ...aidInstancePersonCharacterXrefService.java | 4 + .../service/RaidLayoutService.java | 4 + .../CalendarEventValidationUtil.java | 191 ++++++++++++++++++ .../validation/ClassGroupValidationUtil.java | 80 ++++++++ .../validation/GameClassValidationUtil.java | 82 ++++++++ .../util/validation/GameValidationUtil.java | 58 ++++++ .../PersonCharacterValidationUtil.java | 132 ++++++++++++ .../util/validation/PersonValidationUtil.java | 92 +++++++++ .../RaidGroupRequestValidationUtil.java | 96 +++++++++ .../validation/RaidGroupValidationUtil.java | 91 +++++++++ .../RaidInstanceValidationUtil.java | 93 +++++++++ .../validation/RaidLayoutValidationUtil.java | 111 ++++++++++ 35 files changed, 1670 insertions(+), 181 deletions(-) create mode 100644 src/main/java/com/mattrixwv/raidbuilder/util/validation/CalendarEventValidationUtil.java create mode 100644 src/main/java/com/mattrixwv/raidbuilder/util/validation/ClassGroupValidationUtil.java create mode 100644 src/main/java/com/mattrixwv/raidbuilder/util/validation/GameClassValidationUtil.java create mode 100644 src/main/java/com/mattrixwv/raidbuilder/util/validation/GameValidationUtil.java create mode 100644 src/main/java/com/mattrixwv/raidbuilder/util/validation/PersonCharacterValidationUtil.java create mode 100644 src/main/java/com/mattrixwv/raidbuilder/util/validation/PersonValidationUtil.java create mode 100644 src/main/java/com/mattrixwv/raidbuilder/util/validation/RaidGroupRequestValidationUtil.java create mode 100644 src/main/java/com/mattrixwv/raidbuilder/util/validation/RaidGroupValidationUtil.java create mode 100644 src/main/java/com/mattrixwv/raidbuilder/util/validation/RaidInstanceValidationUtil.java create mode 100644 src/main/java/com/mattrixwv/raidbuilder/util/validation/RaidLayoutValidationUtil.java diff --git a/src/main/java/com/mattrixwv/raidbuilder/controller/AccountController.java b/src/main/java/com/mattrixwv/raidbuilder/controller/AccountController.java index 3edb8a5..18dd6f6 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/controller/AccountController.java +++ b/src/main/java/com/mattrixwv/raidbuilder/controller/AccountController.java @@ -1,6 +1,7 @@ package com.mattrixwv.raidbuilder.controller; +import java.util.ArrayList; import java.util.List; import java.util.UUID; @@ -144,18 +145,22 @@ public class AccountController{ ObjectNode returnNode = mapper.createObjectNode(); - Account existingAccount = accountService.getByUsername(account.getUsername()); - if(existingAccount != null){ + //TODO: Move this to util + List errors = verifyNewAccount(account); + if(errors.isEmpty()){ + account = accountService.createAccount(account); + + returnNode.put("status", "success"); + returnNode.put("accountId", account.getAccountId().toString()); + + log.info("Created account {}", account.getAccountId()); + } + else{ ArrayNode errorsNode = mapper.createArrayNode(); errorsNode.add("Username already exists"); returnNode.set("errors", errorsNode); returnNode.put("status", "error"); } - else{ - account = accountService.createAccount(account); - returnNode.put("status", "success"); - returnNode.put("accountId", account.getAccountId().toString()); - } return returnNode; @@ -294,23 +299,25 @@ public class AccountController{ log.info("Updating account {}", accountId); - //TODO: Existing account verification - Account oldAccount = accountService.getByAccountId(accountId); + //TODO: Move this to util + List errors = verifyUpdatedAccount(account); + ObjectNode returnNode = mapper.createObjectNode(); - if(oldAccount == null){ + if(errors.isEmpty()){ + Account existingAccount = accountService.getByAccountId(accountId); + existingAccount.setUsername(account.getUsername()); + existingAccount.setEmail(account.getEmail()); + existingAccount.setAccountStatus(account.getAccountStatus()); + accountService.updateAccount(existingAccount); + + returnNode.put("status", "success"); + } + else{ ArrayNode errorsNode = mapper.createArrayNode(); errorsNode.add("Account not found"); returnNode.set("errors", errorsNode); returnNode.put("status", "error"); } - else{ - oldAccount.setUsername(account.getUsername()); - oldAccount.setEmail(account.getEmail()); - oldAccount.setAccountStatus(account.getAccountStatus()); - accountService.updateAccount(oldAccount); - - returnNode.put("status", "success"); - } return returnNode; @@ -339,4 +346,86 @@ public class AccountController{ return returnNode; } + + + private List verifyNewAccount(Account account){ + ArrayList errors = new ArrayList<>(); + + //Check ID + if(account.getAccountId() != null){ + errors.add("Invalid Account ID"); + } + + //Check login exists in entity + if((account.getUsername() == null) || (account.getUsername().isEmpty())){ + errors.add("Invalid Login ID"); + } + else{ + //Check login doesn't exist in db + Account existingAccount = accountService.getByUsername(account.getUsername()); + if(existingAccount != null){ + errors.add("Login ID already exists"); + } + } + + //Check password exists in entity + if((account.getPassword() == null) || (account.getPassword().isEmpty())){ + errors.add("No password found"); + } + + //Check email exists in entity + if((account.getEmail() == null) || (account.getEmail().isEmpty())){ + errors.add("Invalid email"); + } + else{ + //Check email doesn't exist in db + Account existingAccount = accountService.getByEmail(account.getEmail()); + if(existingAccount != null){ + errors.add("Account with email already exists"); + } + } + + return errors; + } + + private List verifyUpdatedAccount(Account account){ + ArrayList errors = new ArrayList<>(); + + //Check ID + if(account.getAccountId() == null){ + errors.add("Invalid Account ID"); + } + + //Verify account exists + Account existingAccount = accountService.getByAccountId(account.getAccountId()); + if(existingAccount == null){ + errors.add("Account not found"); + } + + //Check login exists in entity + if((account.getUsername() == null) || (account.getUsername().isEmpty())){ + errors.add("Invalid Login ID"); + } + else{ + //Check login doesn't exist in db, other than the object itself + Account existingAccountByLogin = accountService.getByUsername(account.getUsername()); + if((existingAccountByLogin != null) && (!existingAccountByLogin.getAccountId().equals(account.getAccountId()))){ + errors.add("Login ID already exists"); + } + } + + //Check email exists in entity + if((account.getEmail() == null) || (account.getEmail().isEmpty())){ + errors.add("Invalid email"); + } + else{ + //Check email doesn't exist in db, other than the object itself + Account existingAccountByEmail = accountService.getByEmail(account.getEmail()); + if((existingAccountByEmail != null) && (!existingAccountByEmail.getAccountId().equals(account.getAccountId()))){ + errors.add("Account with email already exists"); + } + } + + return errors; + } } diff --git a/src/main/java/com/mattrixwv/raidbuilder/controller/AccountTutorialController.java b/src/main/java/com/mattrixwv/raidbuilder/controller/AccountTutorialController.java index 198a2b4..426c45d 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/controller/AccountTutorialController.java +++ b/src/main/java/com/mattrixwv/raidbuilder/controller/AccountTutorialController.java @@ -43,6 +43,7 @@ public class AccountTutorialController{ } + //TODO: Break this up per tutorial? @PutMapping @AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER}) public ObjectNode updateTutorialStatus(@RequestBody AccountTutorialStatus tutorialStatus, Authentication authentication){ diff --git a/src/main/java/com/mattrixwv/raidbuilder/controller/AuthenticationController.java b/src/main/java/com/mattrixwv/raidbuilder/controller/AuthenticationController.java index 1feccb9..c538b09 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/controller/AuthenticationController.java +++ b/src/main/java/com/mattrixwv/raidbuilder/controller/AuthenticationController.java @@ -204,7 +204,6 @@ public class AuthenticationController{ @PostMapping("/forgot/{forgotToken}") @AccountAuthorization(permissions = {}) public ObjectNode setNewPasswordForgot(@PathVariable("forgotToken") UUID forgotToken, @RequestBody ObjectNode passwordNode){ - String newPassword = passwordNode.get("password").asText(); log.info("Confirming user reset password (forget) with token {}", forgotToken); @@ -214,6 +213,11 @@ public class AuthenticationController{ //Verify the account exists Account existingAccount = accountService.getByRefreshToken(forgotToken); if(existingAccount != null){ + String newPassword = passwordNode.get("password").asText(); + if(newPassword.trim().length() <= 0){ + throw new IllegalArgumentException("Invalid password"); + } + existingAccount = accountService.updatePassword(existingAccount.getAccountId(), newPassword); existingAccount.setRefreshToken(null); @@ -244,6 +248,9 @@ public class AuthenticationController{ String currentPassword = requestNode.get("currentPassword").asText(); String newPassword = requestNode.get("newPassword").asText(); + if(newPassword.trim().length() <= 0){ + throw new IllegalArgumentException("Invalid password"); + } Account account = accountService.getByUsername(authentication.getName()); if(!passwordEncoder.matches(currentPassword, account.getPassword())){ @@ -342,45 +349,4 @@ public class AuthenticationController{ return errors; } - - private List verifyUpdatedAccount(Account account){ - ArrayList errors = new ArrayList<>(); - - //Check ID - if(account.getAccountId() == null){ - errors.add("Invalid Account ID"); - } - - //Verify account exists - Account existingAccount = accountService.getByAccountId(account.getAccountId()); - if(existingAccount == null){ - errors.add("Account not found"); - } - - //Check login exists in entity - if((account.getUsername() == null) || (account.getUsername().isEmpty())){ - errors.add("Invalid Login ID"); - } - else{ - //Check login doesn't exist in db, other than the object itself - Account existingAccountByLogin = accountService.getByUsername(account.getUsername()); - if((existingAccountByLogin != null) && (!existingAccountByLogin.getAccountId().equals(account.getAccountId()))){ - errors.add("Login ID already exists"); - } - } - - //Check email exists in entity - if((account.getEmail() == null) || (account.getEmail().isEmpty())){ - errors.add("Invalid email"); - } - else{ - //Check email doesn't exist in db, other than the object itself - Account existingAccountByEmail = accountService.getByEmail(account.getEmail()); - if((existingAccountByEmail != null) && (!existingAccountByEmail.getAccountId().equals(account.getAccountId()))){ - errors.add("Account with email already exists"); - } - } - - return errors; - } } diff --git a/src/main/java/com/mattrixwv/raidbuilder/controller/CalendarController.java b/src/main/java/com/mattrixwv/raidbuilder/controller/CalendarController.java index c51c219..f51fab6 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/controller/CalendarController.java +++ b/src/main/java/com/mattrixwv/raidbuilder/controller/CalendarController.java @@ -14,6 +14,7 @@ import org.springframework.web.bind.annotation.RequestMapping; 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.GameAuthorization; @@ -27,6 +28,7 @@ import com.mattrixwv.raidbuilder.service.RaidInstanceService; import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.AccountPermissionType; import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.GamePermissionType; import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.RaidGroupPermissionType; +import com.mattrixwv.raidbuilder.util.validation.CalendarEventValidationUtil; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; @@ -41,6 +43,8 @@ public class CalendarController{ private final GameCalendarEventService gceService; private final RaidGroupCalendarEventService rgceService; private final RaidInstanceService raidInstanceService; + //Utilities + private final CalendarEventValidationUtil cevUtil; //! Game @@ -61,10 +65,21 @@ public class CalendarController{ gameCalendarEvent.setGameId(gameId); - gceService.createGameCalendarEvent(gameCalendarEvent); - ObjectNode returnNode = mapper.createObjectNode(); - returnNode.put("status", "success"); + List errors = cevUtil.validateExistingGameCalendarEvent(gameCalendarEvent); + if(errors.isEmpty()){ + gameCalendarEvent = gceService.createGameCalendarEvent(gameCalendarEvent); + + returnNode.put("status", "success"); + returnNode.put("gameCalendarEventId", gameCalendarEvent.getGameCalendarEventId().toString()); + } + else{ + returnNode.put("status", "error"); + ArrayNode errorNode = mapper.createArrayNode(); + errors.forEach(errorNode::add); + returnNode.set("errors", errorNode); + } + return returnNode; } @@ -77,10 +92,21 @@ public class CalendarController{ gameCalendarEvent.setGameId(gameId); - gceService.updateGameCalendarEvent(gameCalendarEvent); - ObjectNode returnNode = mapper.createObjectNode(); - returnNode.put("status", "success"); + List errors = cevUtil.validateExistingGameCalendarEvent(gameCalendarEvent); + if(errors.isEmpty()){ + gameCalendarEvent = gceService.updateGameCalendarEvent(gameCalendarEvent); + + returnNode.put("status", "success"); + returnNode.put("gameCalendarEventId", gameCalendarEvent.getGameCalendarEventId().toString()); + } + else{ + returnNode.put("status", "error"); + ArrayNode errorNode = mapper.createArrayNode(); + errors.forEach(errorNode::add); + returnNode.set("errors", errorNode); + } + return returnNode; } @@ -92,10 +118,19 @@ public class CalendarController{ log.info("Deleting calendar event for game {}", gameId); - gceService.deleteGameCalendarEvent(calendarEventId); - ObjectNode returnNode = mapper.createObjectNode(); - returnNode.put("status", "success"); + GameCalendarEvent gce = gceService.getById(calendarEventId); + if(gce != null){ + gceService.deleteGameCalendarEvent(calendarEventId); + + returnNode.put("status", "success"); + } + else{ + ArrayNode errorsNode = mapper.createArrayNode(); + errorsNode.add("Calendar event ID is invalid"); + returnNode.put("status", "error"); + returnNode.set("errors", errorsNode); + } return returnNode; } @@ -120,10 +155,22 @@ public class CalendarController{ raidGroupCalendarEvent.setRaidGroupId(raidGroupId); - rgceService.createRaidGroupCalendarEvent(raidGroupCalendarEvent); - ObjectNode returnNode = mapper.createObjectNode(); - returnNode.put("status", "success"); + List errors = cevUtil.validateNewRaidGroupCalendarEvent(raidGroupCalendarEvent); + if(errors.isEmpty()){ + rgceService.createRaidGroupCalendarEvent(raidGroupCalendarEvent); + + returnNode.put("status", "success"); + returnNode.put("raidGroupCalendarEventId", raidGroupCalendarEvent.getRaidGroupCalendarEventId().toString()); + + log.info("Created Raid Group Calendar Event {}", raidGroupCalendarEvent.getRaidGroupCalendarEventId()); + } + else{ + returnNode.put("status", "error"); + ArrayNode errorNode = mapper.createArrayNode(); + errors.forEach(errorNode::add); + returnNode.set("errors", errorNode); + } return returnNode; } @@ -136,10 +183,21 @@ public class CalendarController{ raidGroupCalendarEvent.setRaidGroupId(raidGroupId); - rgceService.updateRaidGroupCalendarEvent(raidGroupCalendarEvent); ObjectNode returnNode = mapper.createObjectNode(); - returnNode.put("status", "success"); + List errors = cevUtil.validateExistingRaidGroupCalendarEvent(raidGroupCalendarEvent); + if(errors.isEmpty()){ + rgceService.updateRaidGroupCalendarEvent(raidGroupCalendarEvent); + + returnNode.put("status", "success"); + returnNode.put("raidGroupCalendarEventId", raidGroupCalendarEvent.getRaidGroupCalendarEventId().toString()); + } + else{ + returnNode.put("status", "error"); + ArrayNode errorNode = mapper.createArrayNode(); + errors.forEach(errorNode::add); + returnNode.set("errors", errorNode); + } return returnNode; } @@ -151,10 +209,20 @@ public class CalendarController{ log.info("Deleting calendar event for raid group {}", raidGroupId); - rgceService.deleteRaidGroupCalendarEvent(calendarEventId); - ObjectNode returnNode = mapper.createObjectNode(); - returnNode.put("status", "success"); + GameCalendarEvent gce = gceService.getById(calendarEventId); + if(gce != null){ + gceService.deleteGameCalendarEvent(calendarEventId); + + returnNode.put("status", "success"); + returnNode.put("raidGroupCalendarEventId", gce.getGameCalendarEventId().toString()); + } + else{ + ArrayNode errorsNode = mapper.createArrayNode(); + errorsNode.add("Calendar event ID is invalid"); + returnNode.put("status", "error"); + returnNode.set("errors", errorsNode); + } return returnNode; } diff --git a/src/main/java/com/mattrixwv/raidbuilder/controller/ClassGroupController.java b/src/main/java/com/mattrixwv/raidbuilder/controller/ClassGroupController.java index 9ed1285..d169335 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/controller/ClassGroupController.java +++ b/src/main/java/com/mattrixwv/raidbuilder/controller/ClassGroupController.java @@ -17,6 +17,7 @@ import org.springframework.web.bind.annotation.RestController; import com.fasterxml.jackson.core.JsonProcessingException; 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; @@ -25,6 +26,7 @@ import com.mattrixwv.raidbuilder.entity.ClassGroupGameClassXref; import com.mattrixwv.raidbuilder.service.ClassGroupService; import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.AccountPermissionType; import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.RaidGroupPermissionType; +import com.mattrixwv.raidbuilder.util.validation.ClassGroupValidationUtil; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; @@ -35,8 +37,10 @@ import lombok.extern.slf4j.Slf4j; @RequestMapping("/raidGroup/{raidGroupId}/classGroup") @RequiredArgsConstructor public class ClassGroupController{ - private final ObjectMapper mapper = new ObjectMapper(); + private final ObjectMapper mapper; private final ClassGroupService classGroupService; + //Utilities + private final ClassGroupValidationUtil cgvUtil; @GetMapping @@ -116,11 +120,24 @@ public class ClassGroupController{ xref.setGameClassId(gameClassId); xrefs.add(xref); } - classGroup = classGroupService.createClassGroup(classGroup, xrefs); + List errors = cgvUtil.validateNewClassGroup(classGroup); ObjectNode returnNode = mapper.createObjectNode(); - returnNode.put("classGroupId", classGroup.getClassGroupId().toString()); - returnNode.put("status", "success"); + if(errors.isEmpty()){ + classGroup = classGroupService.createClassGroup(classGroup, xrefs); + + returnNode.put("status", "success"); + returnNode.put("classGroupId", classGroup.getClassGroupId().toString()); + + log.info("Created Class Group {}", classGroup.getClassGroupId()); + } + else{ + returnNode.put("status", "error"); + ArrayNode errorNode = mapper.createArrayNode(); + errors.forEach(errorNode::add); + returnNode.set("errors", errorNode); + } + return returnNode; } @@ -142,12 +159,22 @@ public class ClassGroupController{ xref.setGameClassId(gameClassId); xrefs.add(xref); } - classGroupService.updateClassGroup(classGroup, xrefs); - + List errors = cgvUtil.validateExistingClassGroup(classGroup); ObjectNode returnNode = mapper.createObjectNode(); - returnNode.put("classGroupId", classGroup.getClassGroupId().toString()); - returnNode.put("status", "success"); + if(errors.isEmpty()){ + classGroupService.updateClassGroup(classGroup, xrefs); + + returnNode.put("classGroupId", classGroup.getClassGroupId().toString()); + returnNode.put("status", "success"); + } + else{ + returnNode.put("status", "error"); + ArrayNode errorNode = mapper.createArrayNode(); + errors.forEach(errorNode::add); + returnNode.set("errors", errorNode); + } + return returnNode; } @@ -159,10 +186,20 @@ public class ClassGroupController{ log.info("Deleting class group {} for raid group {}", classGroupId, raidGroupId); - classGroupService.deleteClassGroup(classGroupId, raidGroupId); + ClassGroup classGroup = classGroupService.getClassGroup(classGroupId, raidGroupId); ObjectNode returnNode = mapper.createObjectNode(); - returnNode.put("status", "success"); + if(classGroup != null){ + classGroupService.deleteClassGroup(classGroupId, raidGroupId); + + returnNode.put("status", "success"); + } + else{ + returnNode.put("status", "error"); + ArrayNode errorNode = mapper.createArrayNode(); + errorNode.add("Class group ID is invalid"); + returnNode.set("errors", errorNode); + } return returnNode; } diff --git a/src/main/java/com/mattrixwv/raidbuilder/controller/GameClassController.java b/src/main/java/com/mattrixwv/raidbuilder/controller/GameClassController.java index bbdf079..4344628 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/controller/GameClassController.java +++ b/src/main/java/com/mattrixwv/raidbuilder/controller/GameClassController.java @@ -15,6 +15,7 @@ import org.springframework.web.bind.annotation.RestController; import org.springframework.web.multipart.MultipartFile; 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.GameAuthorization; @@ -22,6 +23,7 @@ import com.mattrixwv.raidbuilder.entity.GameClass; import com.mattrixwv.raidbuilder.service.GameClassService; import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.AccountPermissionType; import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.GamePermissionType; +import com.mattrixwv.raidbuilder.util.validation.GameClassValidationUtil; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; @@ -34,6 +36,8 @@ import lombok.extern.slf4j.Slf4j; public class GameClassController{ private final ObjectMapper mapper; private final GameClassService gameClassService; + //Utilities + private final GameClassValidationUtil gcvUtil; @GetMapping("/{gameClassId}") @@ -107,12 +111,22 @@ public class GameClassController{ GameClass gameClass = new GameClass(); gameClass.setGameId(gameId); gameClass.setGameClassName(gameClassName); - gameClassService.createGameClass(gameClass, file); + List errors = gcvUtil.validateNewGameClass(gameClass); + if(errors.isEmpty()){ + gameClassService.createGameClass(gameClass, file); - returnNode.put("gameClassId", gameClass.getGameClassId().toString()); - returnNode.put("status", "success"); + returnNode.put("status", "success"); + returnNode.put("gameClassId", gameClass.getGameClassId().toString()); + + log.info("Successfully created game class: {}", gameClass.getGameClassId()); + } + else{ + returnNode.put("status", "error"); + ArrayNode errorNode = mapper.createArrayNode(); + errors.forEach(errorNode::add); + returnNode.set("errors", errorNode); + } - log.info("Successfully created game class: {}", gameClass.getGameClassId()); return returnNode; } @@ -130,12 +144,20 @@ public class GameClassController{ gameClass.setGameId(gameId); gameClass.setGameClassName(gameClassName); gameClass.setGameClassIcon(gameClassIcon); - gameClassService.updateGameClass(gameClass, file); + List errors = gcvUtil.validateExistingGameClass(gameClass); + if(errors.isEmpty()){ + gameClassService.updateGameClass(gameClass, file); - returnNode.put("gameClassId", gameClass.getGameClassId().toString()); - returnNode.put("status", "success"); + returnNode.put("gameClassId", gameClass.getGameClassId().toString()); + returnNode.put("status", "success"); + } + else{ + returnNode.put("status", "error"); + ArrayNode errorNode = mapper.createArrayNode(); + errors.forEach(errorNode::add); + returnNode.set("errors", errorNode); + } - log.info("Successfully updated game class: {}", gameClass.getGameClassId()); return returnNode; } @@ -147,11 +169,19 @@ public class GameClassController{ log.info("Deleting game class {}", gameClassId); + GameClass gameClass = gameClassService.getById(gameClassId); ObjectNode returnNode = mapper.createObjectNode(); - gameClassService.deleteById(gameClassId); - returnNode.put("status", "success"); + if(gameClass != null){ + gameClassService.deleteById(gameClassId); + returnNode.put("status", "success"); + } + else{ + returnNode.put("status", "error"); + ArrayNode errorNode = mapper.createArrayNode(); + errorNode.add("Game class ID is invalid"); + returnNode.set("errors", errorNode); + } - log.info("Successfully deleted game class: {}", gameClassId); return returnNode; } diff --git a/src/main/java/com/mattrixwv/raidbuilder/controller/GameController.java b/src/main/java/com/mattrixwv/raidbuilder/controller/GameController.java index b93b56c..397e653 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/controller/GameController.java +++ b/src/main/java/com/mattrixwv/raidbuilder/controller/GameController.java @@ -15,6 +15,7 @@ import org.springframework.web.bind.annotation.RestController; import org.springframework.web.multipart.MultipartFile; 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.GameAuthorization; @@ -22,6 +23,7 @@ import com.mattrixwv.raidbuilder.entity.Game; import com.mattrixwv.raidbuilder.service.GameService; import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.AccountPermissionType; import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.GamePermissionType; +import com.mattrixwv.raidbuilder.util.validation.GameValidationUtil; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; @@ -34,8 +36,19 @@ import lombok.extern.slf4j.Slf4j; public class GameController{ private final ObjectMapper mapper; private final GameService gameService; + //Utilities + private final GameValidationUtil gvUtil; + @GetMapping("/{gameId}") + @AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER}) + public Game getGame(@PathVariable("gameId") UUID gameId){ + log.info("Getting game {}", gameId); + + + return gameService.getGameById(gameId); + } + @GetMapping @AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER}) public List getGames(@RequestParam("page") int page, @RequestParam("pageSize") int pageSize, @RequestParam(value = "searchTerm", required = false) String searchTerm){ @@ -85,28 +98,29 @@ public class GameController{ log.info("Creating game {}", gameName); - //TODO: New game verification ObjectNode returnNode = mapper.createObjectNode(); Game game = new Game(); game.setGameName(gameName); - game = gameService.createGame(game, file); - returnNode.put("gameId", game.getGameId().toString()); - returnNode.put("status", "success"); + List errors = gvUtil.validateNewGame(game); + if(errors.isEmpty()){ + game = gameService.createGame(game, file); + + returnNode.put("gameId", game.getGameId().toString()); + returnNode.put("status", "success"); + + log.info("Successfully created game: {}", game.getGameId()); + } + else{ + returnNode.put("status", "error"); + ArrayNode errorNode = mapper.createArrayNode(); + errors.forEach(errorNode::add); + returnNode.set("errors", errorNode); + } - log.info("Successfully created game: {}", game.getGameId()); return returnNode; } - @GetMapping("/{gameId}") - @AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER}) - public Game getGame(@PathVariable("gameId") UUID gameId){ - log.info("Getting game {}", gameId); - - - return gameService.getGameById(gameId); - } - @PutMapping("/{gameId}") @AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER}) @GameAuthorization(permissions = {GamePermissionType.ADMIN}) @@ -119,11 +133,19 @@ public class GameController{ game.setGameId(gameId); game.setGameName(gameName); game.setGameIcon(gameIcon); - game = gameService.updateGame(game, file); - returnNode.put("gameId", game.getGameId().toString()); - returnNode.put("status", "success"); + List errors = gvUtil.validateExistingGame(game); + if(errors.isEmpty()){ + game = gameService.updateGame(game, file); - log.info("Successfully updated game: {}", game.getGameId()); + returnNode.put("gameId", game.getGameId().toString()); + returnNode.put("status", "success"); + } + else{ + returnNode.put("status", "error"); + ArrayNode errorNode = mapper.createArrayNode(); + errors.forEach(errorNode::add); + returnNode.set("errors", errorNode); + } return returnNode; } @@ -136,10 +158,19 @@ public class GameController{ ObjectNode returnNode = mapper.createObjectNode(); - gameService.deleteById(gameId); - returnNode.put("status", "success"); + Game game = gameService.getGameById(gameId); + if(game != null){ + gameService.deleteById(gameId); + + returnNode.put("status", "success"); + } + else{ + returnNode.put("status", "error"); + ArrayNode errorNode = mapper.createArrayNode(); + errorNode.add("Game ID is invalid"); + returnNode.set("errors", errorNode); + } - log.info("Successfully deleted game: {}", gameId); return returnNode; } diff --git a/src/main/java/com/mattrixwv/raidbuilder/controller/PersonCharacterController.java b/src/main/java/com/mattrixwv/raidbuilder/controller/PersonCharacterController.java index 39b3512..4e0080a 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/controller/PersonCharacterController.java +++ b/src/main/java/com/mattrixwv/raidbuilder/controller/PersonCharacterController.java @@ -15,6 +15,7 @@ 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; @@ -22,6 +23,7 @@ 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 com.mattrixwv.raidbuilder.util.validation.PersonCharacterValidationUtil; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; @@ -34,6 +36,8 @@ import lombok.extern.slf4j.Slf4j; public class PersonCharacterController{ private final ObjectMapper mapper; private final PersonCharacterService personCharacterService; + //Utilities + private final PersonCharacterValidationUtil pcvUtil; @GetMapping @@ -91,37 +95,80 @@ public class PersonCharacterController{ @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){ + public ObjectNode 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; + ObjectNode returnNode = mapper.createObjectNode(); + List errors = pcvUtil.validateNewPersonCharacter(personCharacter, raidGroupId); + if(errors.isEmpty()){ + personCharacter = personCharacterService.createPersonCharacter(personCharacter); + + returnNode.put("status", "success"); + returnNode.put("personCharacterId", personCharacter.getPersonCharacterId().toString()); + + log.info("Created person character {} for person {}", personCharacter.getCharacterName(), personId); + } + else{ + returnNode.put("status", "error"); + returnNode.set("errors", mapper.valueToTree(errors)); + } + + + return returnNode; } @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){ + public ObjectNode 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; + ObjectNode returnNode = mapper.createObjectNode(); + List errors = pcvUtil.validateExistingPersonCharacter(personCharacter, raidGroupId); + if(errors.isEmpty()){ + personCharacter = personCharacterService.updatePersonCharacter(personCharacter); + + returnNode.put("status", "success"); + returnNode.put("personCharacterId", personCharacter.getPersonCharacterId().toString()); + } + else{ + returnNode.put("status", "error"); + returnNode.set("errors", mapper.valueToTree(errors)); + } + + + return returnNode; } @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){ + public ObjectNode 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); + ObjectNode returnNode = mapper.createObjectNode(); + PersonCharacter personCharacter = personCharacterService.getById(characterId); + if(personCharacter != null){ + personCharacterService.deletePersonCharacter(characterId); + + returnNode.put("status", "success"); + } + else{ + ArrayNode errorsNode = mapper.createArrayNode(); + errorsNode.add("Person character not found"); + returnNode.put("status", "error"); + returnNode.set("errors", errorsNode); + } + + + return returnNode; } } diff --git a/src/main/java/com/mattrixwv/raidbuilder/controller/PersonController.java b/src/main/java/com/mattrixwv/raidbuilder/controller/PersonController.java index 0acefd3..71fd8f3 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/controller/PersonController.java +++ b/src/main/java/com/mattrixwv/raidbuilder/controller/PersonController.java @@ -23,6 +23,7 @@ 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 com.mattrixwv.raidbuilder.util.validation.PersonValidationUtil; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; @@ -35,6 +36,8 @@ import lombok.extern.slf4j.Slf4j; public class PersonController{ private final ObjectMapper mapper; private final PersonService personService; + //Utils + private final PersonValidationUtil pvUtil; @GetMapping @@ -96,30 +99,55 @@ public class PersonController{ @PostMapping @AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER}) @RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN, RaidGroupPermissionType.LEADER}) - public Person createPerson(@PathVariable("raidGroupId") UUID raidGroupId, @RequestBody Person person){ + public ObjectNode createPerson(@PathVariable("raidGroupId") UUID raidGroupId, @RequestBody Person person){ log.info("Creating person for raid group {}", raidGroupId); person.setRaidGroupId(raidGroupId); - person = personService.createPerson(person); + + ObjectNode returnNode = mapper.createObjectNode(); + List errors = pvUtil.validateNewPerson(person); + if(errors.isEmpty()){ + person = personService.createPerson(person); + + returnNode.put("status", "success"); + returnNode.put("personId", person.getPersonId().toString()); + + log.info("Created person {} for raid group {}", person.getPersonName(), raidGroupId); + } + else{ + returnNode.put("status", "error"); + returnNode.set("errors", mapper.valueToTree(errors)); + } - return person; + return returnNode; } @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){ + public ObjectNode 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); + + ObjectNode returnNode = mapper.createObjectNode(); + List errors = pvUtil.validateExistingPerson(person); + if(errors.isEmpty()){ + person = personService.updatePerson(person); + + returnNode.put("status", "success"); + } + else{ + returnNode.put("status", "error"); + returnNode.set("errors", mapper.valueToTree(errors)); + } - return person; + return returnNode; } @DeleteMapping("/{personId}") diff --git a/src/main/java/com/mattrixwv/raidbuilder/controller/RaidGroupController.java b/src/main/java/com/mattrixwv/raidbuilder/controller/RaidGroupController.java index f3b58c8..38eb864 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/controller/RaidGroupController.java +++ b/src/main/java/com/mattrixwv/raidbuilder/controller/RaidGroupController.java @@ -15,6 +15,7 @@ import org.springframework.web.bind.annotation.RestController; import org.springframework.web.multipart.MultipartFile; 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; @@ -24,6 +25,7 @@ import com.mattrixwv.raidbuilder.service.PersonCharacterService; import com.mattrixwv.raidbuilder.service.RaidGroupService; import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.AccountPermissionType; import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.RaidGroupPermissionType; +import com.mattrixwv.raidbuilder.util.validation.RaidGroupValidationUtil; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; @@ -37,6 +39,8 @@ public class RaidGroupController{ private final ObjectMapper mapper; private final RaidGroupService raidGroupService; private final PersonCharacterService personCharacterService; + //Utilities + private final RaidGroupValidationUtil rgvUtil; @GetMapping @@ -86,17 +90,24 @@ public class RaidGroupController{ log.info("Creating raid group {}", raidGroupName); - //TODO: New raid group verification ObjectNode returnNode = mapper.createObjectNode(); RaidGroup raidGroup = new RaidGroup(); raidGroup.setGameId(gameId); raidGroup.setRaidGroupName(raidGroupName); - raidGroupService.createRaidGroup(raidGroup, file); + List errors = rgvUtil.validateNewRaidGroup(raidGroup); + if(errors.isEmpty()){ + raidGroupService.createRaidGroup(raidGroup, file); - returnNode.put("raidGroupId", raidGroup.getRaidGroupId().toString()); - returnNode.put("status", "success"); + returnNode.put("raidGroupId", raidGroup.getRaidGroupId().toString()); + returnNode.put("status", "success"); + + log.info("Created raid group {}", raidGroup.getRaidGroupName()); + } + else{ + returnNode.put("status", "fail"); + returnNode.set("errors", mapper.valueToTree(errors)); + } - log.info("Successfully created raid group: {}", raidGroup.getRaidGroupId()); return returnNode; } @@ -128,12 +139,18 @@ public class RaidGroupController{ raidGroup.setGameId(gameId); raidGroup.setRaidGroupName(raidGroupName); raidGroup.setRaidGroupIcon(raidGroupIcon); - raidGroupService.updateRaidGroup(raidGroup, file); + List errors = rgvUtil.validateExistingRaidGroup(raidGroup); + if(errors.isEmpty()){ + raidGroupService.updateRaidGroup(raidGroup, file); - returnNode.put("raidGroupId", raidGroup.getRaidGroupId().toString()); - returnNode.put("status", "success"); + returnNode.put("raidGroupId", raidGroup.getRaidGroupId().toString()); + returnNode.put("status", "success"); + } + else{ + returnNode.put("status", "fail"); + returnNode.set("errors", mapper.valueToTree(errors)); + } - log.info("Successfully updated raid group: {}", raidGroup.getRaidGroupId()); return returnNode; } @@ -146,10 +163,18 @@ public class RaidGroupController{ ObjectNode returnNode = mapper.createObjectNode(); - raidGroupService.deleteById(raidGroupId); - returnNode.put("status", "success"); + RaidGroup existingRaidGroup = raidGroupService.getByRaidGroupId(raidGroupId); + if(existingRaidGroup != null){ + raidGroupService.deleteById(raidGroupId); + returnNode.put("status", "success"); + } + else{ + returnNode.put("status", "fail"); + ArrayNode errorsNode = mapper.createArrayNode(); + errorsNode.add("Raid group does not exist"); + returnNode.set("errors", errorsNode); + } - log.info("Successfully deleted raid group: {}", raidGroupId); return returnNode; } diff --git a/src/main/java/com/mattrixwv/raidbuilder/controller/RaidGroupRequestController.java b/src/main/java/com/mattrixwv/raidbuilder/controller/RaidGroupRequestController.java index d2e57c7..644e001 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/controller/RaidGroupRequestController.java +++ b/src/main/java/com/mattrixwv/raidbuilder/controller/RaidGroupRequestController.java @@ -16,6 +16,7 @@ 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; @@ -25,6 +26,7 @@ import com.mattrixwv.raidbuilder.service.AccountService; import com.mattrixwv.raidbuilder.service.RaidGroupRequestService; import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.AccountPermissionType; import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.RaidGroupPermissionType; +import com.mattrixwv.raidbuilder.util.validation.RaidGroupRequestValidationUtil; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; @@ -38,6 +40,8 @@ public class RaidGroupRequestController{ private final ObjectMapper mapper; private final AccountService accountService; private final RaidGroupRequestService rgrService; + //Utilities + private final RaidGroupRequestValidationUtil rgrvUtil; @GetMapping @@ -98,17 +102,30 @@ public class RaidGroupRequestController{ @PostMapping @AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER}) - public RaidGroupRequest createRaidGroupRequest(@PathVariable("raidGroupId") UUID raidGroupId, @RequestBody RaidGroupRequest raidGroupRequest, Authentication authentication){ + public ObjectNode createRaidGroupRequest(@PathVariable("raidGroupId") UUID raidGroupId, @RequestBody RaidGroupRequest raidGroupRequest, Authentication authentication){ log.info("Creating raid group request for raid group id: {}", raidGroupId); Account account = accountService.getByUsername(authentication.getName()); raidGroupRequest.setAccountId(account.getAccountId()); raidGroupRequest.setRaidGroupId(raidGroupId); - raidGroupRequest = rgrService.createRaidGroupRequest(raidGroupRequest); + ObjectNode returnNode = mapper.createObjectNode(); + List errors = rgrvUtil.validateNewRaidGroupRequest(raidGroupRequest); + if(errors.isEmpty()){ + raidGroupRequest = rgrService.createRaidGroupRequest(raidGroupRequest); + + returnNode.put("status", "success"); + returnNode.put("raidGroupRequestId", raidGroupRequest.getRaidGroupRequestId().toString()); + + log.info("Created raid group request for raid group id: {}", raidGroupId); + } + else{ + returnNode.put("status", "fail"); + returnNode.set("errors", mapper.valueToTree(errors)); + } - return raidGroupRequest; + return returnNode; } @PutMapping("/{raidGroupRequestId}") @@ -119,10 +136,18 @@ public class RaidGroupRequestController{ raidGroupRequest.setRaidGroupRequestId(raidGroupRequestId); raidGroupRequest.setRaidGroupId(raidGroupId); - raidGroupRequest = rgrService.updateRaidGroupRequest(raidGroupRequest); - ObjectNode returnNode = mapper.createObjectNode(); - returnNode.put("status", "success"); + List errors = rgrvUtil.validateExistingRaidGroupRequest(raidGroupRequest); + if(errors.isEmpty()){ + raidGroupRequest = rgrService.updateRaidGroupRequest(raidGroupRequest); + + returnNode.put("status", "success"); + returnNode.put("raidGroupRequestId", raidGroupRequest.getRaidGroupRequestId().toString()); + } + else{ + returnNode.put("status", "fail"); + returnNode.set("errors", mapper.valueToTree(errors)); + } return returnNode; @@ -134,10 +159,19 @@ public class RaidGroupRequestController{ log.info("Deleting raid group request for raid group id: {}", raidGroupId); - rgrService.deleteRaidGroupRequest(raidGroupRequestId); - ObjectNode returnNode = mapper.createObjectNode(); - returnNode.put("status", "success"); + RaidGroupRequest existingRaidGroupRequest = rgrService.getById(raidGroupRequestId); + if(existingRaidGroupRequest != null){ + rgrService.deleteRaidGroupRequest(raidGroupRequestId); + + returnNode.put("status", "success"); + } + else{ + returnNode.put("status", "fail"); + ArrayNode errorsNode = mapper.createArrayNode(); + errorsNode.add("Raid Group Request does not exist"); + returnNode.set("errors", errorsNode); + } return returnNode; diff --git a/src/main/java/com/mattrixwv/raidbuilder/controller/RaidInstanceController.java b/src/main/java/com/mattrixwv/raidbuilder/controller/RaidInstanceController.java index 9593930..25f4441 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/controller/RaidInstanceController.java +++ b/src/main/java/com/mattrixwv/raidbuilder/controller/RaidInstanceController.java @@ -16,6 +16,7 @@ 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; @@ -23,6 +24,7 @@ import com.mattrixwv.raidbuilder.entity.RaidInstance; import com.mattrixwv.raidbuilder.service.RaidInstanceService; import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.AccountPermissionType; import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.RaidGroupPermissionType; +import com.mattrixwv.raidbuilder.util.validation.RaidInstanceValidationUtil; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; @@ -35,6 +37,8 @@ import lombok.extern.slf4j.Slf4j; public class RaidInstanceController{ private final ObjectMapper mapper; private final RaidInstanceService raidInstanceService; + //Utilities + private final RaidInstanceValidationUtil rivUtil; @GetMapping @@ -94,32 +98,55 @@ public class RaidInstanceController{ @PostMapping @AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER}) @RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN, RaidGroupPermissionType.LEADER}) - public RaidInstance createRaidInstance(@PathVariable("raidGroupId") UUID raidGroupId, @RequestBody RaidInstance raidInstance){ + public ObjectNode createRaidInstance(@PathVariable("raidGroupId") UUID raidGroupId, @RequestBody RaidInstance raidInstance){ log.info("Creating raid instance for raid group {}", raidGroupId); raidInstance.setRaidGroupId(raidGroupId); - RaidInstance createdRaidInstance = raidInstanceService.createRaidInstance(raidInstance); - log.debug("Created raid instance {}", createdRaidInstance); + ObjectNode returnNode = mapper.createObjectNode(); + List errors = rivUtil.validateNewRaidInstance(raidInstance); + if(errors.isEmpty()){ + RaidInstance createdRaidInstance = raidInstanceService.createRaidInstance(raidInstance); + + returnNode.put("status", "success"); + returnNode.put("raidInstanceId", createdRaidInstance.getRaidInstanceId().toString()); + + log.info("Created raid instance {}", createdRaidInstance); + } + else{ + returnNode.put("status", "error"); + returnNode.set("errors", mapper.valueToTree(errors)); + } - return createdRaidInstance; + + return returnNode; } @PutMapping("/{raidInstanceId}") @AccountAuthorization(permissions = {AccountPermissionType.ADMIN, AccountPermissionType.USER}) @RaidGroupAuthorization(permissions = {RaidGroupPermissionType.ADMIN, RaidGroupPermissionType.LEADER}) - public RaidInstance updateRaidInstance(@PathVariable("raidGroupId") UUID raidGroupId, @PathVariable("raidInstanceId") UUID raidInstanceId, @RequestBody RaidInstance raidInstance){ + public ObjectNode updateRaidInstance(@PathVariable("raidGroupId") UUID raidGroupId, @PathVariable("raidInstanceId") UUID raidInstanceId, @RequestBody RaidInstance raidInstance){ log.info("Updating raid instance {} for raid group {}", raidInstanceId, raidGroupId); raidInstance.setRaidInstanceId(raidInstanceId); raidInstance.setRaidGroupId(raidGroupId); - RaidInstance updatedRaidInstance = raidInstanceService.updateRaidInstance(raidInstance); - log.debug("Updated raid instance {}", updatedRaidInstance); + ObjectNode returnNode = mapper.createObjectNode(); + List errors = rivUtil.validateExistingRaidInstance(raidInstance); + if(errors.isEmpty()){ + RaidInstance updatedRaidInstance = raidInstanceService.updateRaidInstance(raidInstance); + + returnNode.put("status", "success"); + returnNode.put("raidInstanceId", updatedRaidInstance.getRaidInstanceId().toString()); + } + else{ + returnNode.put("status", "error"); + returnNode.set("errors", mapper.valueToTree(errors)); + } - return updatedRaidInstance; + return returnNode; } @DeleteMapping("/{raidInstanceId}") @@ -129,10 +156,18 @@ public class RaidInstanceController{ log.info("Deleting raid instance {} for raid group {}", raidInstanceId, raidGroupId); - raidInstanceService.deleteById(raidInstanceId); - ObjectNode returnNode = mapper.createObjectNode(); - returnNode.put("status", "success"); + if(raidInstanceService.findById(raidInstanceId) == null){ + returnNode.put("status", "fail"); + ArrayNode errorsNode = mapper.createArrayNode(); + errorsNode.add("Raid instance does not exist"); + returnNode.set("errors", errorsNode); + } + else{ + raidInstanceService.deleteById(raidInstanceId); + + returnNode.put("status", "success"); + } return returnNode; diff --git a/src/main/java/com/mattrixwv/raidbuilder/controller/RaidLayoutController.java b/src/main/java/com/mattrixwv/raidbuilder/controller/RaidLayoutController.java index 183339c..52abf06 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/controller/RaidLayoutController.java +++ b/src/main/java/com/mattrixwv/raidbuilder/controller/RaidLayoutController.java @@ -15,6 +15,7 @@ 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; @@ -23,6 +24,7 @@ import com.mattrixwv.raidbuilder.entity.RaidLayoutClassGroupXref; import com.mattrixwv.raidbuilder.service.RaidLayoutService; import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.AccountPermissionType; import com.mattrixwv.raidbuilder.util.DatabaseTypeUtil.RaidGroupPermissionType; +import com.mattrixwv.raidbuilder.util.validation.RaidLayoutValidationUtil; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; @@ -36,6 +38,8 @@ import lombok.extern.slf4j.Slf4j; public class RaidLayoutController{ private final ObjectMapper mapper; private final RaidLayoutService raidLayoutService; + //Utilities + private final RaidLayoutValidationUtil rlvUtil; @GetMapping @@ -94,11 +98,20 @@ public class RaidLayoutController{ RaidLayoutClassGroupXref[] xrefsArray = mapper.convertValue(bodyNode.get("raidLayoutClassGroupXrefs"), RaidLayoutClassGroupXref[].class); List xrefs = List.of(xrefsArray); - raidLayout = raidLayoutService.createRaidLayout(raidLayout, xrefs); - ObjectNode returnNode = mapper.createObjectNode(); - returnNode.put("raidLayoutId", raidLayout.getRaidLayoutId().toString()); - returnNode.put("status", "success"); + List errors = rlvUtil.validateNewRaidLayout(raidLayout); + if(errors.isEmpty()){ + raidLayout = raidLayoutService.createRaidLayout(raidLayout, xrefs); + + returnNode.put("raidLayoutId", raidLayout.getRaidLayoutId().toString()); + returnNode.put("status", "success"); + + log.info("Created Raid Layout {} for Raid Group {}", raidLayout.getRaidLayoutId(), raidGroupId); + } + else{ + returnNode.put("status", "fail"); + returnNode.set("errors", mapper.valueToTree(errors)); + } return returnNode; } @@ -116,11 +129,19 @@ public class RaidLayoutController{ RaidLayoutClassGroupXref[] xrefsArray = mapper.convertValue(bodyNode.get("raidLayoutClassGroupXrefs"), RaidLayoutClassGroupXref[].class); List xrefs = List.of(xrefsArray); - raidLayoutService.updateRaidLayout(raidLayout, xrefs); - ObjectNode returnNode = mapper.createObjectNode(); - returnNode.put("raidLayoutId", raidLayout.getRaidLayoutId().toString()); - returnNode.put("status", "success"); + List errors = rlvUtil.validateExistingRaidLayout(raidLayout); + if(errors.isEmpty()){ + raidLayoutService.updateRaidLayout(raidLayout, xrefs); + + returnNode.put("status", "success"); + returnNode.put("raidLayoutId", raidLayout.getRaidLayoutId().toString()); + } + else{ + returnNode.put("status", "fail"); + returnNode.set("errors", mapper.valueToTree(errors)); + } + return returnNode; } @@ -132,10 +153,19 @@ public class RaidLayoutController{ log.info("Deleting Raid Layout {} for Raid Group {}", raidLayoutId, raidGroupId); - raidLayoutService.deleteRaidLayout(raidLayoutId, raidGroupId); - ObjectNode returnNode = mapper.createObjectNode(); - returnNode.put("status", "success"); + RaidLayout raidLayout = raidLayoutService.getRaidLayout(raidLayoutId, raidGroupId); + if(raidLayout == null){ + ArrayNode errorsNode = mapper.createArrayNode(); + errorsNode.add("Raid Layout doesn't exist"); + returnNode.put("status", "fail"); + returnNode.set("errors", errorsNode); + } + else{ + raidLayoutService.deleteRaidLayout(raidLayoutId, raidGroupId); + + returnNode.put("status", "success"); + } return returnNode; diff --git a/src/main/java/com/mattrixwv/raidbuilder/repository/person/PersonRepository.java b/src/main/java/com/mattrixwv/raidbuilder/repository/person/PersonRepository.java index a2ffd33..fba5874 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/repository/person/PersonRepository.java +++ b/src/main/java/com/mattrixwv/raidbuilder/repository/person/PersonRepository.java @@ -14,6 +14,7 @@ public interface PersonRepository extends PersonCustomRepository, JpaRepository< public void deleteAllByRaidGroupId(UUID raidGroupId); public void deleteAllByRaidGroupIdIn(Iterable raidGroupIds); + public Person findByPersonNameAndRaidGroupId(String personName, UUID raidGroupId); public List findAllByRaidGroupId(UUID raidGroupId); public List findAllByRaidGroupIdIn(Iterable raidGroupIds); diff --git a/src/main/java/com/mattrixwv/raidbuilder/repository/person_character/PersonCharacterRepository.java b/src/main/java/com/mattrixwv/raidbuilder/repository/person_character/PersonCharacterRepository.java index 91c04e1..3dcfff2 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/repository/person_character/PersonCharacterRepository.java +++ b/src/main/java/com/mattrixwv/raidbuilder/repository/person_character/PersonCharacterRepository.java @@ -15,7 +15,7 @@ public interface PersonCharacterRepository extends PersonCharacterCustomReposito public void deleteAllByPersonIdIn(Iterable personIds); - public PersonCharacter findByPersonCharacterId(UUID personCharacterId); + public PersonCharacter findByPersonIdAndCharacterName(UUID personId, String characterName); public List findAllByPersonId(UUID personId); public List findAllByPersonId(UUID personId, PageRequest pageRequest); public List findAllByPersonIdAndCharacterNameContainingIgnoreCase(UUID personId, String searchTerm, PageRequest pageRequest); diff --git a/src/main/java/com/mattrixwv/raidbuilder/repository/raid_group/RaidGroupRepository.java b/src/main/java/com/mattrixwv/raidbuilder/repository/raid_group/RaidGroupRepository.java index c283dbf..849a926 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/repository/raid_group/RaidGroupRepository.java +++ b/src/main/java/com/mattrixwv/raidbuilder/repository/raid_group/RaidGroupRepository.java @@ -11,6 +11,8 @@ import com.mattrixwv.raidbuilder.entity.RaidGroup; public interface RaidGroupRepository extends RaidGroupCustomRepository, JpaRepository{ + public RaidGroup findByRaidGroupNameAndGameId(String raidGroupName, UUID gameId); + public List findAllByGameId(UUID gameId); public List findAllByGameId(UUID gameId, PageRequest pageRequest); public List findAllByRaidGroupNameContainingIgnoreCase(String searchTerm, PageRequest pageRequest); diff --git a/src/main/java/com/mattrixwv/raidbuilder/repository/raid_layout/RaidLayoutRepository.java b/src/main/java/com/mattrixwv/raidbuilder/repository/raid_layout/RaidLayoutRepository.java index 387dfe3..03493a3 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/repository/raid_layout/RaidLayoutRepository.java +++ b/src/main/java/com/mattrixwv/raidbuilder/repository/raid_layout/RaidLayoutRepository.java @@ -17,6 +17,7 @@ public interface RaidLayoutRepository extends RaidLayoutCustomRepository, JpaRep public RaidLayout findByRaidLayoutIdAndRaidGroupId(UUID raidLayoutId, UUID raidGroupId); + public RaidLayout findByRaidLayoutNameAndRaidGroupId(String raidLayoutName, UUID raidGroupId); public List findAllByRaidGroupId(UUID raidGroupId); public List findAllByRaidGroupId(UUID raidGroupId, PageRequest pageRequest); public List findAllByRaidGroupIdIn(Iterable raidGroupIds); diff --git a/src/main/java/com/mattrixwv/raidbuilder/service/GameCalendarEventService.java b/src/main/java/com/mattrixwv/raidbuilder/service/GameCalendarEventService.java index 1cce1d5..cd426cf 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/service/GameCalendarEventService.java +++ b/src/main/java/com/mattrixwv/raidbuilder/service/GameCalendarEventService.java @@ -21,12 +21,12 @@ public class GameCalendarEventService{ //Write - public void createGameCalendarEvent(GameCalendarEvent gce){ - gceRepository.save(gce); + public GameCalendarEvent createGameCalendarEvent(GameCalendarEvent gce){ + return gceRepository.save(gce); } - public void updateGameCalendarEvent(GameCalendarEvent gce){ - gceRepository.save(gce); + public GameCalendarEvent updateGameCalendarEvent(GameCalendarEvent gce){ + return gceRepository.save(gce); } public void deleteGameCalendarEvent(UUID gceId){ @@ -39,6 +39,10 @@ public class GameCalendarEventService{ //Read + public GameCalendarEvent getById(UUID gceId){ + return gceRepository.findById(gceId).orElse(null); + } + public List getByGameId(UUID gameId){ return gceRepository.findAllByGameId(gameId); } diff --git a/src/main/java/com/mattrixwv/raidbuilder/service/PersonCharacterService.java b/src/main/java/com/mattrixwv/raidbuilder/service/PersonCharacterService.java index 955bffb..0af962e 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/service/PersonCharacterService.java +++ b/src/main/java/com/mattrixwv/raidbuilder/service/PersonCharacterService.java @@ -46,6 +46,14 @@ public class PersonCharacterService{ //Read + public PersonCharacter getById(UUID personCharacterId){ + return personCharacterRepository.findById(personCharacterId).orElse(null); + } + + public PersonCharacter getByPersonIdAndCharacterName(UUID personId, String characterName){ + return personCharacterRepository.findByPersonIdAndCharacterName(personId, characterName); + } + public List getByPersonId(UUID personId){ return personCharacterRepository.findAllByPersonId(personId); } diff --git a/src/main/java/com/mattrixwv/raidbuilder/service/PersonService.java b/src/main/java/com/mattrixwv/raidbuilder/service/PersonService.java index ffc47b4..df1684a 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/service/PersonService.java +++ b/src/main/java/com/mattrixwv/raidbuilder/service/PersonService.java @@ -65,6 +65,11 @@ public class PersonService{ } } + public Person getPersonByName(String personName, UUID raidGroupId){ + return personRepository.findByPersonNameAndRaidGroupId(personName, raidGroupId); + + } + public List getPeopleByRaidGroup(UUID raidGroupId, int page, int pageSize){ return personRepository.findAllByRaidGroupId(raidGroupId, PageRequest.of(page, pageSize, Sort.by("personName").ascending())); } diff --git a/src/main/java/com/mattrixwv/raidbuilder/service/RaidGroupCalendarEventService.java b/src/main/java/com/mattrixwv/raidbuilder/service/RaidGroupCalendarEventService.java index 3c8fe51..197c1ef 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/service/RaidGroupCalendarEventService.java +++ b/src/main/java/com/mattrixwv/raidbuilder/service/RaidGroupCalendarEventService.java @@ -45,6 +45,10 @@ public class RaidGroupCalendarEventService{ //Read + public RaidGroupCalendarEvent getByRaidGroupCalendarEventId(UUID rgceId){ + return rgceRepository.findById(rgceId).orElse(null); + } + public List getByRaidGroupId(UUID raidGroupId){ return rgceRepository.findAllByRaidGroupId(raidGroupId); } diff --git a/src/main/java/com/mattrixwv/raidbuilder/service/RaidGroupRequestService.java b/src/main/java/com/mattrixwv/raidbuilder/service/RaidGroupRequestService.java index c50d757..490bc50 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/service/RaidGroupRequestService.java +++ b/src/main/java/com/mattrixwv/raidbuilder/service/RaidGroupRequestService.java @@ -61,6 +61,10 @@ public class RaidGroupRequestService{ //Read + public RaidGroupRequest getById(UUID raidGroupRequestId){ + return rgrRepository.findById(raidGroupRequestId).orElseThrow(); + } + public List getByAccountId(UUID accountId){ return rgrRepository.findAllByAccountId(accountId); } diff --git a/src/main/java/com/mattrixwv/raidbuilder/service/RaidGroupService.java b/src/main/java/com/mattrixwv/raidbuilder/service/RaidGroupService.java index 7d061b3..2a72b2e 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/service/RaidGroupService.java +++ b/src/main/java/com/mattrixwv/raidbuilder/service/RaidGroupService.java @@ -151,6 +151,11 @@ public class RaidGroupService{ return raidGroupRepository.findById(raidGroupId).orElse(null); } + public RaidGroup getByRaidGroupName(String raidGroupName, UUID gameId){ + return raidGroupRepository.findByRaidGroupNameAndGameId(raidGroupName, gameId); + + } + public List getRaidGroups(int page, int pageSize){ return raidGroupRepository.findAll(PageRequest.of(page, pageSize, Sort.by("raidGroupName").ascending())).getContent(); } diff --git a/src/main/java/com/mattrixwv/raidbuilder/service/RaidInstancePersonCharacterXrefService.java b/src/main/java/com/mattrixwv/raidbuilder/service/RaidInstancePersonCharacterXrefService.java index 16b8ad5..21e1ae4 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/service/RaidInstancePersonCharacterXrefService.java +++ b/src/main/java/com/mattrixwv/raidbuilder/service/RaidInstancePersonCharacterXrefService.java @@ -55,6 +55,10 @@ public class RaidInstancePersonCharacterXrefService{ //Read + public RaidInstancePersonCharacterXref getById(UUID ripcxId){ + return raidInstancePersonCharacterXrefRepository.findById(ripcxId).orElseThrow(); + } + public List getByRaidInstanceId(UUID raidInstanceId){ return raidInstancePersonCharacterXrefRepository.findAllByRaidInstanceId(raidInstanceId); } diff --git a/src/main/java/com/mattrixwv/raidbuilder/service/RaidLayoutService.java b/src/main/java/com/mattrixwv/raidbuilder/service/RaidLayoutService.java index 9b79e6a..cafba22 100644 --- a/src/main/java/com/mattrixwv/raidbuilder/service/RaidLayoutService.java +++ b/src/main/java/com/mattrixwv/raidbuilder/service/RaidLayoutService.java @@ -75,6 +75,10 @@ public class RaidLayoutService{ return raidLayoutRepository.findByRaidLayoutIdAndRaidGroupId(raidLayoutId, raidGroupId); } + public RaidLayout getRaidLayoutByName(String raidLayoutName, UUID raidGroupId){ + return raidLayoutRepository.findByRaidLayoutNameAndRaidGroupId(raidLayoutName, raidGroupId); + } + public List getRaidLayoutsByRaidGroupId(UUID raidGroupId, int page, int pageSize){ return raidLayoutRepository.findAllByRaidGroupId(raidGroupId, PageRequest.of(page, pageSize, Sort.by("raidLayoutName").ascending())); } diff --git a/src/main/java/com/mattrixwv/raidbuilder/util/validation/CalendarEventValidationUtil.java b/src/main/java/com/mattrixwv/raidbuilder/util/validation/CalendarEventValidationUtil.java new file mode 100644 index 0000000..3fd9634 --- /dev/null +++ b/src/main/java/com/mattrixwv/raidbuilder/util/validation/CalendarEventValidationUtil.java @@ -0,0 +1,191 @@ +package com.mattrixwv.raidbuilder.util.validation; + + +import java.util.ArrayList; +import java.util.List; + +import org.springframework.stereotype.Component; + +import com.mattrixwv.raidbuilder.entity.Game; +import com.mattrixwv.raidbuilder.entity.GameCalendarEvent; +import com.mattrixwv.raidbuilder.entity.RaidGroup; +import com.mattrixwv.raidbuilder.entity.RaidGroupCalendarEvent; +import com.mattrixwv.raidbuilder.service.GameCalendarEventService; +import com.mattrixwv.raidbuilder.service.GameService; +import com.mattrixwv.raidbuilder.service.RaidGroupCalendarEventService; +import com.mattrixwv.raidbuilder.service.RaidGroupService; + +import lombok.RequiredArgsConstructor; + + +@Component +@RequiredArgsConstructor +public class CalendarEventValidationUtil{ + private final GameCalendarEventService gceService; + private final RaidGroupCalendarEventService rgceService; + private final GameService gameService; + private final RaidGroupService raidGroupService; + + + public List validateNewGameCalendarEvent(GameCalendarEvent gameCalendarEvent){ + ArrayList errors = new ArrayList<>(); + + //Game Calendar Event + if(gameCalendarEvent.getGameCalendarEventId() != null){ + errors.add("Should be creating a new event rather than updating an existing event"); + } + + //Game ID + if(gameCalendarEvent.getGameId() == null){ + errors.add("Game ID is required"); + } + else{ + Game game = gameService.getGameById(gameCalendarEvent.getGameId()); + if(game == null){ + errors.add("Game ID is invalid"); + } + } + + //Event Name + if((gameCalendarEvent.getEventName() == null) || (gameCalendarEvent.getEventName().trim().isEmpty())){ + errors.add("Event name is required"); + } + + //Event Dates + if(gameCalendarEvent.getEventStartDate() == null){ + errors.add("Event start date is required"); + } + if(gameCalendarEvent.getEventEndDate() == null){ + errors.add("Event end date is required"); + } + if(gameCalendarEvent.getEventStartDate().compareTo(gameCalendarEvent.getEventEndDate()) > 0){ + errors.add("Event start date must be before event end date"); + } + + return errors; + } + + public List validateExistingGameCalendarEvent(GameCalendarEvent gameCalendarEvent){ + ArrayList errors = new ArrayList<>(); + + //Game Calendar Event + if(gameCalendarEvent.getGameCalendarEventId() == null){ + errors.add("Game calendar event ID is required"); + return errors; + } + GameCalendarEvent existingGameCalendarEvent = gceService.getById(gameCalendarEvent.getGameCalendarEventId()); + if(existingGameCalendarEvent == null){ + errors.add("Game calendar event ID is invalid"); + } + + //Game ID + if(gameCalendarEvent.getGameId() == null){ + errors.add("Game ID is required"); + } + else{ + Game game = gameService.getGameById(gameCalendarEvent.getGameId()); + if(game == null){ + errors.add("Game ID is invalid"); + } + } + + //Event Name + if((gameCalendarEvent.getEventName() == null) || (gameCalendarEvent.getEventName().trim().isEmpty())){ + errors.add("Event name is required"); + } + + //Event Dates + if(gameCalendarEvent.getEventStartDate() == null){ + errors.add("Event start date is required"); + } + if(gameCalendarEvent.getEventEndDate() == null){ + errors.add("Event end date is required"); + } + if(gameCalendarEvent.getEventStartDate().compareTo(gameCalendarEvent.getEventEndDate()) > 0){ + errors.add("Event start date must be before event end date"); + } + + return errors; + } + + public List validateNewRaidGroupCalendarEvent(RaidGroupCalendarEvent raidGroupCalendarEvent){ + List errors = new ArrayList<>(); + + //Check the ID + if(raidGroupCalendarEvent.getRaidGroupCalendarEventId() != null){ + errors.add("Should be creating a new event rather than updating an existing event"); + } + + //Check the Raid Group ID + if(raidGroupCalendarEvent.getRaidGroupId() == null){ + errors.add("Raid Group ID is required"); + } + else{ + RaidGroup raidGroup = raidGroupService.getByRaidGroupId(raidGroupCalendarEvent.getRaidGroupId()); + if(raidGroup == null){ + errors.add("Raid Group ID is invalid"); + } + } + + //Check the event name + if((raidGroupCalendarEvent.getEventName() == null) || (raidGroupCalendarEvent.getEventName().trim().isEmpty())){ + errors.add("Event name is required"); + } + + //Check the event dates + if(raidGroupCalendarEvent.getEventStartDate() == null){ + errors.add("Event start date is required"); + } + else if(raidGroupCalendarEvent.getEventEndDate() == null){ + errors.add("Event end date is required"); + } + else if(raidGroupCalendarEvent.getEventStartDate().compareTo(raidGroupCalendarEvent.getEventEndDate()) > 0){ + errors.add("Event start date must be before event end date"); + } + + return errors; + } + + public List validateExistingRaidGroupCalendarEvent(RaidGroupCalendarEvent raidGroupCalendarEvent){ + List errors = new ArrayList<>(); + + //Check the ID + if(raidGroupCalendarEvent.getRaidGroupCalendarEventId() == null){ + errors.add("Raid Group Calendar Event ID is required"); + return errors; + } + RaidGroupCalendarEvent existingRaidGroupCalendarEvent = rgceService.getByRaidGroupCalendarEventId(raidGroupCalendarEvent.getRaidGroupCalendarEventId()); + if(existingRaidGroupCalendarEvent == null){ + errors.add("Raid Group Calendar Event ID is invalid"); + } + + //Check the Raid Group ID + if(raidGroupCalendarEvent.getRaidGroupId() == null){ + errors.add("Raid Group ID is required"); + } + else{ + RaidGroup raidGroup = raidGroupService.getByRaidGroupId(raidGroupCalendarEvent.getRaidGroupId()); + if(raidGroup == null){ + errors.add("Raid Group ID is invalid"); + } + } + + //Check the event name + if((raidGroupCalendarEvent.getEventName() == null) || (raidGroupCalendarEvent.getEventName().trim().isEmpty())){ + errors.add("Event name is required"); + } + + //Check the event dates + if(raidGroupCalendarEvent.getEventStartDate() == null){ + errors.add("Event start date is required"); + } + else if(raidGroupCalendarEvent.getEventEndDate() == null){ + errors.add("Event end date is required"); + } + else if(raidGroupCalendarEvent.getEventStartDate().compareTo(raidGroupCalendarEvent.getEventEndDate()) > 0){ + errors.add("Event start date must be before event end date"); + } + + return errors; + } +} diff --git a/src/main/java/com/mattrixwv/raidbuilder/util/validation/ClassGroupValidationUtil.java b/src/main/java/com/mattrixwv/raidbuilder/util/validation/ClassGroupValidationUtil.java new file mode 100644 index 0000000..b9e3d10 --- /dev/null +++ b/src/main/java/com/mattrixwv/raidbuilder/util/validation/ClassGroupValidationUtil.java @@ -0,0 +1,80 @@ +package com.mattrixwv.raidbuilder.util.validation; + + +import java.util.ArrayList; +import java.util.List; + +import org.springframework.stereotype.Component; + +import com.mattrixwv.raidbuilder.entity.ClassGroup; +import com.mattrixwv.raidbuilder.entity.RaidGroup; +import com.mattrixwv.raidbuilder.service.ClassGroupService; +import com.mattrixwv.raidbuilder.service.RaidGroupService; + +import lombok.RequiredArgsConstructor; + + +@Component +@RequiredArgsConstructor +public class ClassGroupValidationUtil{ + private final ClassGroupService classGroupService; + private final RaidGroupService raidGroupService; + + + public List validateNewClassGroup(ClassGroup classGroup){ + ArrayList errors = new ArrayList<>(); + + //Class Group ID + if(classGroup.getClassGroupId() != null){ + errors.add("Class group ID must be null"); + } + + //Raid Group ID + if(classGroup.getRaidGroupId() == null){ + errors.add("Raid group ID is required"); + } + RaidGroup raidGroup = raidGroupService.getByRaidGroupId(classGroup.getRaidGroupId()); + if(raidGroup == null){ + errors.add("Raid group ID is invalid"); + } + + //Class Group Name + if((classGroup.getClassGroupName() == null) || (classGroup.getClassGroupName().trim().isEmpty())){ + errors.add("Class group name is required"); + } + + return errors; + } + + public List validateExistingClassGroup(ClassGroup classGroup){ + ArrayList errors = new ArrayList<>(); + + //Class Group Id + if(classGroup.getClassGroupId() == null){ + errors.add("Class group ID is required"); + return errors; + } + ClassGroup existingClassGroup = classGroupService.getClassGroup(classGroup.getClassGroupId(), classGroup.getRaidGroupId()); + if(existingClassGroup == null){ + errors.add("Class group ID is invalid"); + } + + //Raid Group ID + if(classGroup.getRaidGroupId() == null){ + errors.add("Raid group ID is required"); + } + else{ + RaidGroup raidGroup = raidGroupService.getByRaidGroupId(classGroup.getRaidGroupId()); + if(raidGroup == null){ + errors.add("Raid group ID is invalid"); + } + } + + //Class Group Name + if((classGroup.getClassGroupName() == null) || (classGroup.getClassGroupName().trim().isEmpty())){ + errors.add("Class group name is required"); + } + + return errors; + } +} diff --git a/src/main/java/com/mattrixwv/raidbuilder/util/validation/GameClassValidationUtil.java b/src/main/java/com/mattrixwv/raidbuilder/util/validation/GameClassValidationUtil.java new file mode 100644 index 0000000..33763b2 --- /dev/null +++ b/src/main/java/com/mattrixwv/raidbuilder/util/validation/GameClassValidationUtil.java @@ -0,0 +1,82 @@ +package com.mattrixwv.raidbuilder.util.validation; + + +import java.util.ArrayList; +import java.util.List; + +import org.springframework.stereotype.Component; + +import com.mattrixwv.raidbuilder.entity.Game; +import com.mattrixwv.raidbuilder.entity.GameClass; +import com.mattrixwv.raidbuilder.service.GameClassService; +import com.mattrixwv.raidbuilder.service.GameService; + +import lombok.RequiredArgsConstructor; + + +@Component +@RequiredArgsConstructor +public class GameClassValidationUtil{ + private final GameService gameService; + private final GameClassService gameClassService; + + + public List validateNewGameClass(GameClass gameClass){ + ArrayList errors = new ArrayList<>(); + + //Game Class ID + if(gameClass.getGameClassId() != null){ + errors.add("Game class ID must be null"); + } + + //Game ID + if(gameClass.getGameId() == null){ + errors.add("Game ID is required"); + } + Game game = gameService.getGameById(gameClass.getGameId()); + if(game == null){ + errors.add("Game ID is invalid"); + } + + //Game Class Name + if((gameClass.getGameClassName() == null) || (gameClass.getGameClassName().trim().isEmpty())){ + errors.add("Game class name is required"); + } + + + return errors; + } + + public List validateExistingGameClass(GameClass gameClass){ + ArrayList errors = new ArrayList<>(); + + //Game Class ID + if(gameClass.getGameClassId() == null){ + errors.add("Game class ID is required"); + return errors; + } + GameClass existingGameClass = gameClassService.getById(gameClass.getGameClassId()); + if(existingGameClass == null){ + errors.add("Game class ID is invalid"); + } + + //Game ID + if(gameClass.getGameId() == null){ + errors.add("Game ID is required"); + } + else{ + Game game = gameService.getGameById(gameClass.getGameId()); + if(game == null){ + errors.add("Game ID is invalid"); + } + } + + //Game Class Name + if((gameClass.getGameClassName() == null) || (gameClass.getGameClassName().trim().isEmpty())){ + errors.add("Game class name is required"); + } + + + return errors; + } +} diff --git a/src/main/java/com/mattrixwv/raidbuilder/util/validation/GameValidationUtil.java b/src/main/java/com/mattrixwv/raidbuilder/util/validation/GameValidationUtil.java new file mode 100644 index 0000000..e49a422 --- /dev/null +++ b/src/main/java/com/mattrixwv/raidbuilder/util/validation/GameValidationUtil.java @@ -0,0 +1,58 @@ +package com.mattrixwv.raidbuilder.util.validation; + + +import java.util.ArrayList; +import java.util.List; + +import org.springframework.stereotype.Component; + +import com.mattrixwv.raidbuilder.entity.Game; +import com.mattrixwv.raidbuilder.service.GameService; + +import lombok.RequiredArgsConstructor; + + +@Component +@RequiredArgsConstructor +public class GameValidationUtil{ + private final GameService gameService; + + + public List validateNewGame(Game game){ + ArrayList errors = new ArrayList<>(); + + //Game ID + if(game.getGameId() != null){ + errors.add("Game ID must be null"); + } + + //Game Name + if((game.getGameName() == null) || (game.getGameName().trim().isEmpty())){ + errors.add("Game name is required"); + } + + return errors; + } + + public List validateExistingGame(Game game){ + ArrayList errors = new ArrayList<>(); + + //Game ID + if(game.getGameId() == null){ + errors.add("Game ID is required"); + return errors; + } + + Game existingGame = gameService.getGameById(game.getGameId()); + if(existingGame == null){ + errors.add("Game ID is invalid"); + } + + //Game Name + if((game.getGameName() == null) || (game.getGameName().trim().isEmpty())){ + errors.add("Game name is required"); + } + + return errors; + } +} diff --git a/src/main/java/com/mattrixwv/raidbuilder/util/validation/PersonCharacterValidationUtil.java b/src/main/java/com/mattrixwv/raidbuilder/util/validation/PersonCharacterValidationUtil.java new file mode 100644 index 0000000..a185026 --- /dev/null +++ b/src/main/java/com/mattrixwv/raidbuilder/util/validation/PersonCharacterValidationUtil.java @@ -0,0 +1,132 @@ +package com.mattrixwv.raidbuilder.util.validation; + + +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; + +import org.springframework.stereotype.Component; + +import com.mattrixwv.raidbuilder.entity.GameClass; +import com.mattrixwv.raidbuilder.entity.Person; +import com.mattrixwv.raidbuilder.entity.PersonCharacter; +import com.mattrixwv.raidbuilder.service.GameClassService; +import com.mattrixwv.raidbuilder.service.PersonCharacterService; +import com.mattrixwv.raidbuilder.service.PersonService; + +import lombok.RequiredArgsConstructor; + + +@Component +@RequiredArgsConstructor +public class PersonCharacterValidationUtil{ + private final GameClassService gameClassService; + private final PersonService person; + private final PersonCharacterService personCharacterService; + + + public List validateNewPersonCharacter(PersonCharacter personCharacter, UUID raidGroupId){ + ArrayList errors = new ArrayList<>(); + + //Person Character ID + if(personCharacter.getPersonCharacterId() != null){ + errors.add("Person character ID must be null"); + } + + //Person ID + if(personCharacter.getPersonId() == null){ + errors.add("Person ID is required"); + } + else{ + Person existingPerson = person.getPerson(personCharacter.getPersonId(), raidGroupId); + if(existingPerson == null){ + errors.add("Person ID is invalid"); + } + } + + //Game Class ID + if(personCharacter.getGameClassId() == null){ + errors.add("Game class ID is required"); + } + else{ + GameClass existingGameClass = gameClassService.getById(personCharacter.getGameClassId()); + if(existingGameClass == null){ + errors.add("Game class ID is invalid"); + } + } + + //Character Name + if((personCharacter.getCharacterName() == null) || (personCharacter.getCharacterName().trim().isEmpty())){ + errors.add("Character name is required"); + } + else{ + PersonCharacter existingPersonCharacter = personCharacterService.getByPersonIdAndCharacterName(personCharacter.getPersonId(), personCharacter.getCharacterName()); + if(existingPersonCharacter != null){ + errors.add("Character name already exists for this person"); + } + } + + //Rating + if((personCharacter.getCharacterRating() < 0) || personCharacter.getCharacterRating() > 10){ + errors.add("Character rating must be between 0 and 10"); + } + + + return errors; + } + + public List validateExistingPersonCharacter(PersonCharacter personCharacter, UUID raidGroupId){ + ArrayList errors = new ArrayList<>(); + + //Person Character ID + if(personCharacter.getPersonCharacterId() == null){ + errors.add("Person character ID is required"); + return errors; + } + PersonCharacter existingPersonCharacter = personCharacterService.getById(personCharacter.getPersonCharacterId()); + if(existingPersonCharacter == null){ + errors.add("Person character ID is invalid"); + } + + //Person ID + if(personCharacter.getPersonId() == null){ + errors.add("Person ID is required"); + } + else{ + Person existingPerson = person.getPerson(personCharacter.getPersonId(), raidGroupId); + if(existingPerson == null){ + errors.add("Person ID is invalid"); + } + } + + //Game Class ID + if(personCharacter.getGameClassId() == null){ + errors.add("Game class ID is required"); + } + else{ + GameClass existingGameClass = gameClassService.getById(personCharacter.getGameClassId()); + if(existingGameClass == null){ + errors.add("Game class ID is invalid"); + } + } + + //Character Name + if((personCharacter.getCharacterName() == null) || (personCharacter.getCharacterName().trim().isEmpty())){ + errors.add("Character name is required"); + } + else{ + existingPersonCharacter = personCharacterService.getByPersonIdAndCharacterName(personCharacter.getPersonId(), personCharacter.getCharacterName()); + if(existingPersonCharacter != null){ + errors.add("Character name already exists for this person"); + } + } + + //Rating + if((personCharacter.getCharacterRating() < 0) || personCharacter.getCharacterRating() > 10){ + errors.add("Character rating must be between 0 and 10"); + } + + + return errors; + } +} diff --git a/src/main/java/com/mattrixwv/raidbuilder/util/validation/PersonValidationUtil.java b/src/main/java/com/mattrixwv/raidbuilder/util/validation/PersonValidationUtil.java new file mode 100644 index 0000000..ebda298 --- /dev/null +++ b/src/main/java/com/mattrixwv/raidbuilder/util/validation/PersonValidationUtil.java @@ -0,0 +1,92 @@ +package com.mattrixwv.raidbuilder.util.validation; + + +import java.util.ArrayList; +import java.util.List; + +import org.springframework.stereotype.Component; + +import com.mattrixwv.raidbuilder.entity.Person; +import com.mattrixwv.raidbuilder.entity.RaidGroup; +import com.mattrixwv.raidbuilder.service.PersonService; +import com.mattrixwv.raidbuilder.service.RaidGroupService; + +import lombok.RequiredArgsConstructor; + + +@Component +@RequiredArgsConstructor +public class PersonValidationUtil{ + private final PersonService personService; + private final RaidGroupService raidGroupService; + + + public List validateNewPerson(Person person){ + ArrayList errors = new ArrayList<>(); + + //Person ID + if(person.getPersonId() != null){ + errors.add("Person ID must be null"); + } + + //Raid Group ID + if(person.getRaidGroupId() == null){ + errors.add("Raid Group ID is required"); + } + else{ + RaidGroup raidGroup = raidGroupService.getByRaidGroupId(person.getRaidGroupId()); + if(raidGroup == null){ + errors.add("Raid Group ID is invalid"); + } + } + + //Person Name + if((person.getPersonName() == null) || (person.getPersonName().trim().isEmpty())){ + errors.add("Person name is required"); + } + Person existingPerson = personService.getPersonByName(person.getPersonName(), person.getRaidGroupId()); + if(existingPerson != null){ + errors.add("Person name already exists"); + } + + + return errors; + } + + public List validateExistingPerson(Person person){ + ArrayList errors = new ArrayList<>(); + + //Person ID + if(person.getPersonId() == null){ + errors.add("Person ID is required"); + return errors; + } + Person existingPerson = personService.getPerson(person.getPersonId(), person.getRaidGroupId()); + if(existingPerson == null){ + errors.add("Person ID is invalid"); + } + + //Raid Group ID + if(person.getRaidGroupId() == null){ + errors.add("Raid Group ID is required"); + } + else{ + RaidGroup raidGroup = raidGroupService.getByRaidGroupId(person.getRaidGroupId()); + if(raidGroup == null){ + errors.add("Raid Group ID is invalid"); + } + } + + //Person Name + if((person.getPersonName() == null) || (person.getPersonName().trim().isEmpty())){ + errors.add("Person name is required"); + } + existingPerson = personService.getPersonByName(person.getPersonName(), person.getRaidGroupId()); + if((existingPerson != null) && (!existingPerson.getPersonId().equals(person.getPersonId()))){ + errors.add("Person name already exists"); + } + + + return errors; + } +} diff --git a/src/main/java/com/mattrixwv/raidbuilder/util/validation/RaidGroupRequestValidationUtil.java b/src/main/java/com/mattrixwv/raidbuilder/util/validation/RaidGroupRequestValidationUtil.java new file mode 100644 index 0000000..743edf5 --- /dev/null +++ b/src/main/java/com/mattrixwv/raidbuilder/util/validation/RaidGroupRequestValidationUtil.java @@ -0,0 +1,96 @@ +package com.mattrixwv.raidbuilder.util.validation; + + +import java.util.ArrayList; +import java.util.List; + +import org.springframework.stereotype.Component; + +import com.mattrixwv.raidbuilder.entity.RaidGroup; +import com.mattrixwv.raidbuilder.entity.RaidGroupRequest; +import com.mattrixwv.raidbuilder.service.AccountService; +import com.mattrixwv.raidbuilder.service.RaidGroupRequestService; +import com.mattrixwv.raidbuilder.service.RaidGroupService; + +import lombok.RequiredArgsConstructor; + + +@Component +@RequiredArgsConstructor +public class RaidGroupRequestValidationUtil{ + private final AccountService accountService; + private final RaidGroupService raidGroupService; + private final RaidGroupRequestService raidGroupRequestService; + + + public List validateNewRaidGroupRequest(RaidGroupRequest raidGroupRequest){ + ArrayList errors = new ArrayList<>(); + + + //Raid Group Request ID + if(raidGroupRequest.getRaidGroupRequestId() != null){ + errors.add("Raid Group Request ID should not exist"); + } + + //Raid Group ID + if(raidGroupRequest.getRaidGroupId() == null){ + errors.add("Raid Group ID is required"); + } + else{ + RaidGroup existingRaidGroup = raidGroupService.getByRaidGroupId(raidGroupRequest.getRaidGroupId()); + if(existingRaidGroup == null){ + errors.add("Raid Group ID does not exist"); + } + } + + //Account ID + if(raidGroupRequest.getAccountId() == null){ + errors.add("Account ID is required"); + } + else{ + if(accountService.getByAccountId(raidGroupRequest.getAccountId()) == null){ + errors.add("Account ID does not exist"); + } + } + + return errors; + } + + public List validateExistingRaidGroupRequest(RaidGroupRequest raidGroupRequest){ + ArrayList errors = new ArrayList<>(); + + + //Raid Group Request ID + if(raidGroupRequest.getRaidGroupRequestId() == null){ + errors.add("Raid Group Request ID is required"); + return errors; + } + RaidGroupRequest existingRaidGroupRequest = raidGroupRequestService.getById(raidGroupRequest.getRaidGroupRequestId()); + if(existingRaidGroupRequest == null){ + errors.add("Raid Group Request ID does not exist"); + } + + //Raid Group ID + if(raidGroupRequest.getRaidGroupId() == null){ + errors.add("Raid Group ID is required"); + } + else{ + RaidGroup existingRaidGroup = raidGroupService.getByRaidGroupId(raidGroupRequest.getRaidGroupId()); + if(existingRaidGroup == null){ + errors.add("Raid Group ID does not exist"); + } + } + + //Account ID + if(raidGroupRequest.getAccountId() == null){ + errors.add("Account ID is required"); + } + else{ + if(accountService.getByAccountId(raidGroupRequest.getAccountId()) == null){ + errors.add("Account ID does not exist"); + } + } + + return errors; + } +} diff --git a/src/main/java/com/mattrixwv/raidbuilder/util/validation/RaidGroupValidationUtil.java b/src/main/java/com/mattrixwv/raidbuilder/util/validation/RaidGroupValidationUtil.java new file mode 100644 index 0000000..a095cd6 --- /dev/null +++ b/src/main/java/com/mattrixwv/raidbuilder/util/validation/RaidGroupValidationUtil.java @@ -0,0 +1,91 @@ +package com.mattrixwv.raidbuilder.util.validation; + + +import java.util.ArrayList; +import java.util.List; + +import org.springframework.stereotype.Component; + +import com.mattrixwv.raidbuilder.entity.Game; +import com.mattrixwv.raidbuilder.entity.RaidGroup; +import com.mattrixwv.raidbuilder.service.GameService; +import com.mattrixwv.raidbuilder.service.RaidGroupService; + +import lombok.RequiredArgsConstructor; + + +@Component +@RequiredArgsConstructor +public class RaidGroupValidationUtil{ + private final GameService gameService; + private final RaidGroupService raidGroupService; + + + public List validateNewRaidGroup(RaidGroup raidGroup){ + ArrayList errors = new ArrayList<>(); + + + //Raid Group ID + if(raidGroup.getRaidGroupId() != null){ + errors.add("Raid Group ID must be null"); + } + + //Game ID + if(raidGroup.getGameId() == null){ + errors.add("Game ID is required"); + } + else{ + Game existingGame = gameService.getGameById(raidGroup.getGameId()); + if(existingGame == null){ + errors.add("Game ID is invalid"); + } + } + + //Raid Group Name + if((raidGroup.getRaidGroupName() == null) || (raidGroup.getRaidGroupName().trim().isEmpty())){ + errors.add("Raid group name is required"); + } + RaidGroup existingRaidGroup = raidGroupService.getByRaidGroupName(raidGroup.getRaidGroupName(), raidGroup.getGameId()); + if(existingRaidGroup != null){ + errors.add("Raid group name already exists"); + } + + return errors; + } + + public List validateExistingRaidGroup(RaidGroup raidGroup){ + ArrayList errors = new ArrayList<>(); + + //Raid Group ID + if(raidGroup.getRaidGroupId() == null){ + errors.add("Raid Group ID is required"); + return errors; + } + RaidGroup existingRaidGroup = raidGroupService.getByRaidGroupId(raidGroup.getRaidGroupId()); + if(existingRaidGroup == null){ + errors.add("Raid Group ID is invalid"); + } + + //Game ID + if(raidGroup.getGameId() == null){ + errors.add("Game ID is required"); + } + else{ + Game existingGame = gameService.getGameById(raidGroup.getGameId()); + if(existingGame == null){ + errors.add("Game ID is invalid"); + } + } + + //Raid Group Name + if((raidGroup.getRaidGroupName() == null) || (raidGroup.getRaidGroupName().trim().isEmpty())){ + errors.add("Raid group name is required"); + } + existingRaidGroup = raidGroupService.getByRaidGroupName(raidGroup.getRaidGroupName(), raidGroup.getGameId()); + if((existingRaidGroup != null) && (!existingRaidGroup.getRaidGroupId().equals(raidGroup.getRaidGroupId()))){ + errors.add("Raid group name already exists"); + } + + return errors; + } +} diff --git a/src/main/java/com/mattrixwv/raidbuilder/util/validation/RaidInstanceValidationUtil.java b/src/main/java/com/mattrixwv/raidbuilder/util/validation/RaidInstanceValidationUtil.java new file mode 100644 index 0000000..fb5edc5 --- /dev/null +++ b/src/main/java/com/mattrixwv/raidbuilder/util/validation/RaidInstanceValidationUtil.java @@ -0,0 +1,93 @@ +package com.mattrixwv.raidbuilder.util.validation; + + +import java.util.ArrayList; +import java.util.List; + +import org.springframework.stereotype.Component; + +import com.mattrixwv.raidbuilder.entity.RaidInstance; +import com.mattrixwv.raidbuilder.service.RaidGroupService; +import com.mattrixwv.raidbuilder.service.RaidInstanceService; + +import lombok.RequiredArgsConstructor; + + +@Component +@RequiredArgsConstructor +public class RaidInstanceValidationUtil{ + private final RaidGroupService raidGroupService; + private final RaidInstanceService raidInstanceService; + + + public List validateNewRaidInstance(RaidInstance raidInstance){ + ArrayList errors = new ArrayList<>(); + + + //Raid Instance ID + if(raidInstance.getRaidInstanceId() != null){ + errors.add("Raid Instance ID should not be provided"); + } + + //Raid Group ID + if(raidInstance.getRaidGroupId() == null){ + errors.add("Raid Group ID is required"); + } + else{ + if(raidGroupService.getByRaidGroupId(raidInstance.getRaidGroupId()) == null){ + errors.add("Raid Group ID is invalid"); + } + } + + //Dates + if(raidInstance.getRaidStartDate() == null){ + errors.add("Start date is required"); + } + if(raidInstance.getRaidEndDate() == null){ + errors.add("End date is required"); + } + if((raidInstance.getRaidStartDate() != null) && (raidInstance.getRaidEndDate() != null) && (raidInstance.getRaidStartDate().compareTo(raidInstance.getRaidEndDate()) > 0)){ + errors.add("Start date must be before end date"); + } + + return errors; + } + + public List validateExistingRaidInstance(RaidInstance raidInstance){ + ArrayList errors = new ArrayList<>(); + + + //Raid Instance ID + if(raidInstance.getRaidInstanceId() == null){ + errors.add("Raid Instance ID should not be provided"); + return errors; + } + RaidInstance existingRaidInstance = raidInstanceService.findById(raidInstance.getRaidInstanceId()); + if(existingRaidInstance != null){ + errors.add("Raid Instance ID is invalid"); + } + + //Raid Group ID + if(raidInstance.getRaidGroupId() == null){ + errors.add("Raid Group ID is required"); + } + else{ + if(raidGroupService.getByRaidGroupId(raidInstance.getRaidGroupId()) == null){ + errors.add("Raid Group ID is invalid"); + } + } + + //Dates + if(raidInstance.getRaidStartDate() == null){ + errors.add("Start date is required"); + } + if(raidInstance.getRaidEndDate() == null){ + errors.add("End date is required"); + } + if((raidInstance.getRaidStartDate() != null) && (raidInstance.getRaidEndDate() != null) && (raidInstance.getRaidStartDate().compareTo(raidInstance.getRaidEndDate()) > 0)){ + errors.add("Start date must be before end date"); + } + + return errors; + } +} diff --git a/src/main/java/com/mattrixwv/raidbuilder/util/validation/RaidLayoutValidationUtil.java b/src/main/java/com/mattrixwv/raidbuilder/util/validation/RaidLayoutValidationUtil.java new file mode 100644 index 0000000..d5d0f0b --- /dev/null +++ b/src/main/java/com/mattrixwv/raidbuilder/util/validation/RaidLayoutValidationUtil.java @@ -0,0 +1,111 @@ +package com.mattrixwv.raidbuilder.util.validation; + + +import java.util.ArrayList; +import java.util.List; + +import org.springframework.stereotype.Component; + +import com.mattrixwv.raidbuilder.entity.RaidLayout; +import com.mattrixwv.raidbuilder.service.RaidGroupService; +import com.mattrixwv.raidbuilder.service.RaidLayoutService; + +import lombok.RequiredArgsConstructor; + + +@Component +@RequiredArgsConstructor +public class RaidLayoutValidationUtil{ + private final RaidGroupService raidGroupService; + private final RaidLayoutService raidLayoutService; + + + public List validateNewRaidLayout(RaidLayout raidLayout){ + ArrayList errors = new ArrayList<>(); + + + //Raid Layout ID + if(raidLayout.getRaidGroupId() != null){ + errors.add("Raid Group ID must be null"); + } + + //Raid Group ID + if(raidLayout.getRaidGroupId() == null){ + errors.add("Raid Group ID is required"); + } + else{ + if(raidGroupService.getByRaidGroupId(raidLayout.getRaidGroupId()) == null){ + errors.add("Raid Group ID is invalid"); + } + } + + //Raid Layout Name + if((raidLayout.getRaidLayoutName() == null) || (raidLayout.getRaidLayoutName().trim().length() == 0)){ + errors.add("Raid Layout Name is required"); + } + else{ + RaidLayout existingRaidLayout = raidLayoutService.getRaidLayoutByName(raidLayout.getRaidLayoutName(), raidLayout.getRaidGroupId()); + if(existingRaidLayout != null){ + errors.add("Raid Layout Name already exists"); + } + } + + //Raid Size + if(raidLayout.getRaidSize() <= 0){ + errors.add("Raid Size must be greater than 0"); + } + else if(raidLayout.getRaidSize() > 100){ + errors.add("Raid Size must be less than or equal to 100"); + } + + + return errors; + } + + public List validateExistingRaidLayout(RaidLayout raidLayout){ + ArrayList errors = new ArrayList<>(); + + + //Raid Layout ID + if(raidLayout.getRaidLayoutId() == null){ + errors.add("Raid Layout ID is required"); + return errors; + } + RaidLayout existingRaidLayout = raidLayoutService.getRaidLayout(raidLayout.getRaidLayoutId(), raidLayout.getRaidGroupId()); + if(existingRaidLayout == null){ + errors.add("Raid Layout ID is invalid"); + } + + //Raid Group ID + if(raidLayout.getRaidGroupId() == null){ + errors.add("Raid Group ID is required"); + } + else{ + if(raidGroupService.getByRaidGroupId(raidLayout.getRaidGroupId()) == null){ + errors.add("Raid Group ID is invalid"); + } + } + + //Raid Layout Name + if((raidLayout.getRaidLayoutName() == null) || (raidLayout.getRaidLayoutName().trim().length() == 0)){ + errors.add("Raid Layout Name is required"); + } + else{ + existingRaidLayout = raidLayoutService.getRaidLayoutByName(raidLayout.getRaidLayoutName(), raidLayout.getRaidGroupId()); + if(existingRaidLayout != null){ + errors.add("Raid Layout Name already exists"); + } + } + + //Raid Size + if(raidLayout.getRaidSize() <= 0){ + errors.add("Raid Size must be greater than 0"); + } + else if(raidLayout.getRaidSize() > 100){ + errors.add("Raid Size must be less than or equal to 100"); + } + + + return errors; + } +}