diff --git a/backend/src/main/java/dev/flima/application/auth/dtos/request/LoginDTORequest.java b/backend/src/main/java/dev/flima/application/auth/dtos/request/LoginDTORequest.java new file mode 100644 index 0000000..6ecdb3d --- /dev/null +++ b/backend/src/main/java/dev/flima/application/auth/dtos/request/LoginDTORequest.java @@ -0,0 +1,15 @@ +package dev.flima.application.auth.dtos.request; + +import dev.flima.domain.users.Password; +import jakarta.validation.Valid; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; + +public record LoginDTORequest( + @NotNull(message = "{username.not_null}") + @NotBlank(message = "{username.not_null}") + String username, + + @Valid + Password password +) {} diff --git a/backend/src/main/java/dev/flima/application/auth/dtos/response/LoginDTOResponse.java b/backend/src/main/java/dev/flima/application/auth/dtos/response/LoginDTOResponse.java new file mode 100644 index 0000000..8472136 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/auth/dtos/response/LoginDTOResponse.java @@ -0,0 +1,9 @@ +package dev.flima.application.auth.dtos.response; + +import dev.flima.domain.users.Role; + +public record LoginDTOResponse( + String username, + Role role, + String token +) {} diff --git a/backend/src/main/java/dev/flima/application/auth/usecases/LoginUseCase.java b/backend/src/main/java/dev/flima/application/auth/usecases/LoginUseCase.java new file mode 100644 index 0000000..465f80c --- /dev/null +++ b/backend/src/main/java/dev/flima/application/auth/usecases/LoginUseCase.java @@ -0,0 +1,46 @@ +package dev.flima.application.auth.usecases; + +import dev.flima.application.auth.dtos.request.LoginDTORequest; +import dev.flima.application.auth.dtos.response.LoginDTOResponse; +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.security.PasswordHasher; +import dev.flima.domain.security.TokenGenerator; +import dev.flima.domain.users.Password; +import dev.flima.domain.users.User; +import dev.flima.domain.users.UserRepository; +import jakarta.enterprise.context.ApplicationScoped; + +import java.util.ResourceBundle; + +@ApplicationScoped +public class LoginUseCase { + + private final UserRepository userRepository; + private final PasswordHasher passwordHasher; + private final TokenGenerator tokenGenerator; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public LoginUseCase(UserRepository userRepository, PasswordHasher passwordHasher, TokenGenerator tokenGenerator) { + this.userRepository = userRepository; + this.passwordHasher = passwordHasher; + this.tokenGenerator = tokenGenerator; + } + + public LoginDTOResponse execute(LoginDTORequest loginDTO) { + User user = userRepository.getUsername(loginDTO.username()) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("auth.login_failed"))); + + + if(!passwordHasher.verify(new Password(loginDTO.password().password()), new Password(user.getPassword().password()))) { + throw new EntityNotFoundException(messages.getString("auth.login_failed")); + } + + String token = tokenGenerator.generateToken(user.getUsername(), user.getRole().name()); + + return new LoginDTOResponse( + user.getUsername(), + user.getRole(), + token + ); + } +} diff --git a/backend/src/main/java/dev/flima/application/contents/dtos/SectionContentDTO.java b/backend/src/main/java/dev/flima/application/contents/dtos/SectionContentDTO.java new file mode 100644 index 0000000..aed741b --- /dev/null +++ b/backend/src/main/java/dev/flima/application/contents/dtos/SectionContentDTO.java @@ -0,0 +1,14 @@ +package dev.flima.application.contents.dtos; + +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; + +public record SectionContentDTO( + @NotNull(message = "{title.not_null_or_empty}") + @NotBlank(message = "{title.not_null_or_empty}") + String title, + + @NotNull(message = "{subtitle.not_null_or_empty}") + @NotBlank(message = "{subtitle.not_null_or_empty}") + String subtitle +) {} diff --git a/backend/src/main/java/dev/flima/application/contents/dtos/request/ContentDTORequest.java b/backend/src/main/java/dev/flima/application/contents/dtos/request/ContentDTORequest.java new file mode 100644 index 0000000..6a6d8d4 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/contents/dtos/request/ContentDTORequest.java @@ -0,0 +1,14 @@ +package dev.flima.application.contents.dtos.request; + +import dev.flima.application.contents.dtos.SectionContentDTO; +import dev.flima.domain.contents.SectionType; +import jakarta.validation.Valid; +import jakarta.validation.constraints.NotNull; + +public record ContentDTORequest( + @NotNull(message = "{content.section_type.not_null}") + SectionType sectionType, + + @Valid + SectionContentDTO sectionContent +) {} diff --git a/backend/src/main/java/dev/flima/application/contents/dtos/response/ContentDTOResponse.java b/backend/src/main/java/dev/flima/application/contents/dtos/response/ContentDTOResponse.java new file mode 100644 index 0000000..b1865d9 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/contents/dtos/response/ContentDTOResponse.java @@ -0,0 +1,12 @@ +package dev.flima.application.contents.dtos.response; + +import dev.flima.application.contents.dtos.SectionContentDTO; +import dev.flima.domain.contents.SectionType; + +import java.util.UUID; + +public record ContentDTOResponse( + UUID id, + SectionType sectionType, + SectionContentDTO sectionContent +) {} diff --git a/backend/src/main/java/dev/flima/application/contents/dtos/response/CreateContentDTOResponse.java b/backend/src/main/java/dev/flima/application/contents/dtos/response/CreateContentDTOResponse.java new file mode 100644 index 0000000..48b2452 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/contents/dtos/response/CreateContentDTOResponse.java @@ -0,0 +1,8 @@ +package dev.flima.application.contents.dtos.response; + +import java.util.UUID; + +public record CreateContentDTOResponse( + UUID id, + String sectionContent +) {} diff --git a/backend/src/main/java/dev/flima/application/contents/usecases/CreateContentUseCase.java b/backend/src/main/java/dev/flima/application/contents/usecases/CreateContentUseCase.java new file mode 100644 index 0000000..0ee9479 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/contents/usecases/CreateContentUseCase.java @@ -0,0 +1,34 @@ +package dev.flima.application.contents.usecases; + +import dev.flima.application.contents.dtos.request.ContentDTORequest; +import dev.flima.application.contents.dtos.response.CreateContentDTOResponse; +import dev.flima.domain.contents.Content; +import dev.flima.domain.contents.ContentRepository; +import dev.flima.domain.contents.SectionContent; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; + +@ApplicationScoped +public class CreateContentUseCase { + + private final ContentRepository contentRepository; + + public CreateContentUseCase(ContentRepository contentRepository) { + this.contentRepository = contentRepository; + } + + @Transactional + public CreateContentDTOResponse execute(ContentDTORequest contentDTO) { + SectionContent sectionContent = new SectionContent(contentDTO.sectionContent().title(), contentDTO.sectionContent().subtitle()); + + Content content = new Content(contentDTO.sectionType(), sectionContent); + + contentRepository.save(content); + + return new CreateContentDTOResponse( + content.getId(), + sectionContent.title() + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/contents/usecases/DeleteContentUseCase.java b/backend/src/main/java/dev/flima/application/contents/usecases/DeleteContentUseCase.java new file mode 100644 index 0000000..67ed111 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/contents/usecases/DeleteContentUseCase.java @@ -0,0 +1,31 @@ +package dev.flima.application.contents.usecases; + +import dev.flima.domain.contents.Content; +import dev.flima.domain.contents.ContentRepository; +import dev.flima.domain.exceptions.EntityNotFoundException; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; +import jakarta.ws.rs.NotFoundException; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class DeleteContentUseCase { + + private final ContentRepository contentRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public DeleteContentUseCase(ContentRepository contentRepository) { + this.contentRepository = contentRepository; + } + + @Transactional + public void execute(UUID id) { + Content content = contentRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("content.not_found"))); + + contentRepository.remove(content); + } + +} diff --git a/backend/src/main/java/dev/flima/application/contents/usecases/GetAllContentUseCase.java b/backend/src/main/java/dev/flima/application/contents/usecases/GetAllContentUseCase.java new file mode 100644 index 0000000..67fc6ea --- /dev/null +++ b/backend/src/main/java/dev/flima/application/contents/usecases/GetAllContentUseCase.java @@ -0,0 +1,35 @@ +package dev.flima.application.contents.usecases; + +import dev.flima.application.contents.dtos.SectionContentDTO; +import dev.flima.application.contents.dtos.response.ContentDTOResponse; +import dev.flima.domain.contents.Content; +import dev.flima.domain.contents.ContentRepository; +import jakarta.enterprise.context.ApplicationScoped; + +import java.util.List; + +@ApplicationScoped +public class GetAllContentUseCase { + + private final ContentRepository contentRepository; + + public GetAllContentUseCase(ContentRepository contentRepository) { + this.contentRepository = contentRepository; + } + + public List execute() { + List contents = contentRepository.getAll(); + + return contents.stream() + .map(content -> new ContentDTOResponse( + content.getId(), + content.getSectionType(), + new SectionContentDTO( + content.getSectionContent().title(), + content.getSectionContent().subtitle() + ) + )) + .toList(); + } + +} diff --git a/backend/src/main/java/dev/flima/application/contents/usecases/GetContentUseCase.java b/backend/src/main/java/dev/flima/application/contents/usecases/GetContentUseCase.java new file mode 100644 index 0000000..01444c7 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/contents/usecases/GetContentUseCase.java @@ -0,0 +1,37 @@ +package dev.flima.application.contents.usecases; + +import dev.flima.application.contents.dtos.SectionContentDTO; +import dev.flima.application.contents.dtos.response.ContentDTOResponse; +import dev.flima.domain.contents.Content; +import dev.flima.domain.contents.ContentRepository; +import dev.flima.domain.exceptions.EntityNotFoundException; +import jakarta.enterprise.context.ApplicationScoped; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class GetContentUseCase { + + private final ContentRepository contentRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public GetContentUseCase(ContentRepository contentRepository) { + this.contentRepository = contentRepository; + } + + public ContentDTOResponse execute(UUID id) { + Content content = contentRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("content.not_found"))); + + return new ContentDTOResponse( + content.getId(), + content.getSectionType(), + new SectionContentDTO( + content.getSectionContent().title(), + content.getSectionContent().subtitle() + ) + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/contents/usecases/UpdateContentUseCase.java b/backend/src/main/java/dev/flima/application/contents/usecases/UpdateContentUseCase.java new file mode 100644 index 0000000..358322e --- /dev/null +++ b/backend/src/main/java/dev/flima/application/contents/usecases/UpdateContentUseCase.java @@ -0,0 +1,47 @@ +package dev.flima.application.contents.usecases; + +import dev.flima.application.contents.dtos.SectionContentDTO; +import dev.flima.application.contents.dtos.request.ContentDTORequest; +import dev.flima.application.contents.dtos.response.ContentDTOResponse; +import dev.flima.domain.contents.Content; +import dev.flima.domain.contents.ContentRepository; +import dev.flima.domain.contents.SectionContent; +import dev.flima.domain.exceptions.EntityNotFoundException; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; +import jakarta.ws.rs.NotFoundException; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class UpdateContentUseCase { + + private final ContentRepository contentRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public UpdateContentUseCase(ContentRepository contentRepository) { + this.contentRepository = contentRepository; + } + + @Transactional + public ContentDTOResponse execute(UUID id, ContentDTORequest contentDTO) { + Content content = contentRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("content.not_found"))); + + content.setSectionType(contentDTO.sectionType()); + content.setSectionContent(new SectionContent(contentDTO.sectionContent().title(), contentDTO.sectionContent().subtitle())); + + contentRepository.modify(content); + + return new ContentDTOResponse( + content.getId(), + content.getSectionType(), + new SectionContentDTO( + content.getSectionContent().title(), + content.getSectionContent().subtitle() + ) + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/educations/dtos/request/EducationDTORequest.java b/backend/src/main/java/dev/flima/application/educations/dtos/request/EducationDTORequest.java new file mode 100644 index 0000000..cdd80c2 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/educations/dtos/request/EducationDTORequest.java @@ -0,0 +1,32 @@ +package dev.flima.application.educations.dtos.request; + +import dev.flima.domain.educations.TypeEducation; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; + +import java.util.List; + +public record EducationDTORequest( + @NotNull(message = "{ducation.type_education.not_null}") + TypeEducation typeEducation, + + @NotNull(message = "{ducation.type_education.not_null}") + @NotBlank(message = "{ducation.type_education.not_null}") + String degree, + + @NotNull(message = "{title.not_null_or_empty}") + @NotBlank(message = "{title.not_null_or_empty}") + String title, + + @NotNull(message = "{education.institution.not_null}") + @NotBlank(message = "{education.institution.not_null}") + String institution, + + @NotNull(message = "{period.not_null_or_empty}") + @NotBlank(message = "{period.not_null_or_empty}") + String period, + + String specialization, + List skills, + List architectures +) {} diff --git a/backend/src/main/java/dev/flima/application/educations/dtos/response/CreateEducationDTOResponse.java b/backend/src/main/java/dev/flima/application/educations/dtos/response/CreateEducationDTOResponse.java new file mode 100644 index 0000000..043ba00 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/educations/dtos/response/CreateEducationDTOResponse.java @@ -0,0 +1,8 @@ +package dev.flima.application.educations.dtos.response; + +import java.util.UUID; + +public record CreateEducationDTOResponse( + UUID id, + String title +) {} diff --git a/backend/src/main/java/dev/flima/application/educations/dtos/response/EducationDTOResponse.java b/backend/src/main/java/dev/flima/application/educations/dtos/response/EducationDTOResponse.java new file mode 100644 index 0000000..626977a --- /dev/null +++ b/backend/src/main/java/dev/flima/application/educations/dtos/response/EducationDTOResponse.java @@ -0,0 +1,18 @@ +package dev.flima.application.educations.dtos.response; + +import dev.flima.domain.educations.TypeEducation; + +import java.util.List; +import java.util.UUID; + +public record EducationDTOResponse( + UUID id, + TypeEducation typeEducation, + String degree, + String title, + String institution, + String period, + String specialization, + Listskills, + List architectures +) {} diff --git a/backend/src/main/java/dev/flima/application/educations/usecases/CreateEducationUseCase.java b/backend/src/main/java/dev/flima/application/educations/usecases/CreateEducationUseCase.java new file mode 100644 index 0000000..a779709 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/educations/usecases/CreateEducationUseCase.java @@ -0,0 +1,40 @@ +package dev.flima.application.educations.usecases; + +import dev.flima.application.educations.dtos.request.EducationDTORequest; +import dev.flima.application.educations.dtos.response.CreateEducationDTOResponse; +import dev.flima.domain.educations.Education; +import dev.flima.domain.educations.EducationRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; + +@ApplicationScoped +public class CreateEducationUseCase { + + private final EducationRepository educationRepository; + + public CreateEducationUseCase(EducationRepository educationRepository) { + this.educationRepository = educationRepository; + } + + @Transactional + public CreateEducationDTOResponse execute(EducationDTORequest educationDTO) { + Education education = new Education( + educationDTO.typeEducation(), + educationDTO.degree(), + educationDTO.title(), + educationDTO.institution(), + educationDTO.period(), + educationDTO.specialization(), + educationDTO.skills(), + educationDTO.architectures() + ); + + educationRepository.save(education); + + return new CreateEducationDTOResponse( + education.getId(), + education.getTitle() + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/educations/usecases/DeleteEducationUseCase.java b/backend/src/main/java/dev/flima/application/educations/usecases/DeleteEducationUseCase.java new file mode 100644 index 0000000..f7fd87a --- /dev/null +++ b/backend/src/main/java/dev/flima/application/educations/usecases/DeleteEducationUseCase.java @@ -0,0 +1,31 @@ +package dev.flima.application.educations.usecases; + +import dev.flima.domain.educations.Education; +import dev.flima.domain.educations.EducationRepository; +import dev.flima.domain.exceptions.EntityNotFoundException; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; +import jakarta.ws.rs.NotFoundException; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class DeleteEducationUseCase { + + private final EducationRepository educationRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public DeleteEducationUseCase(EducationRepository educationRepository) { + this.educationRepository = educationRepository; + } + + @Transactional + public void execute(UUID id) { + Education education = educationRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("education.not_found"))); + + educationRepository.remove(education); + } + +} diff --git a/backend/src/main/java/dev/flima/application/educations/usecases/GetAllEducationUseCase.java b/backend/src/main/java/dev/flima/application/educations/usecases/GetAllEducationUseCase.java new file mode 100644 index 0000000..f67565d --- /dev/null +++ b/backend/src/main/java/dev/flima/application/educations/usecases/GetAllEducationUseCase.java @@ -0,0 +1,34 @@ +package dev.flima.application.educations.usecases; + +import dev.flima.application.educations.dtos.response.EducationDTOResponse; +import dev.flima.domain.educations.EducationRepository; +import jakarta.enterprise.context.ApplicationScoped; + +import java.util.List; + +@ApplicationScoped +public class GetAllEducationUseCase { + + private final EducationRepository educationRepository; + + public GetAllEducationUseCase(EducationRepository educationRepository) { + this.educationRepository = educationRepository; + } + + public List execute() { + return educationRepository.getAll().stream() + .map(education -> new EducationDTOResponse( + education.getId(), + education.getTypeEducation(), + education.getDegree(), + education.getTitle(), + education.getInstitution(), + education.getPeriod(), + education.getSpecialization(), + education.getSkills(), + education.getArchitectures() + )) + .toList(); + } + +} diff --git a/backend/src/main/java/dev/flima/application/educations/usecases/GetEducationUseCase.java b/backend/src/main/java/dev/flima/application/educations/usecases/GetEducationUseCase.java new file mode 100644 index 0000000..a4aa61b --- /dev/null +++ b/backend/src/main/java/dev/flima/application/educations/usecases/GetEducationUseCase.java @@ -0,0 +1,40 @@ +package dev.flima.application.educations.usecases; + +import dev.flima.application.educations.dtos.response.EducationDTOResponse; +import dev.flima.domain.educations.Education; +import dev.flima.domain.educations.EducationRepository; +import dev.flima.domain.exceptions.EntityNotFoundException; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.ws.rs.NotFoundException; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class GetEducationUseCase { + + private final EducationRepository educationRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public GetEducationUseCase(EducationRepository educationRepository) { + this.educationRepository = educationRepository; + } + + public EducationDTOResponse execute(UUID id) { + Education education = educationRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("education.not_found"))); + + return new EducationDTOResponse( + education.getId(), + education.getTypeEducation(), + education.getDegree(), + education.getTitle(), + education.getInstitution(), + education.getPeriod(), + education.getSpecialization(), + education.getSkills(), + education.getArchitectures() + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/educations/usecases/UpdateEducationUseCase.java b/backend/src/main/java/dev/flima/application/educations/usecases/UpdateEducationUseCase.java new file mode 100644 index 0000000..06de96f --- /dev/null +++ b/backend/src/main/java/dev/flima/application/educations/usecases/UpdateEducationUseCase.java @@ -0,0 +1,54 @@ +package dev.flima.application.educations.usecases; + +import dev.flima.application.educations.dtos.request.EducationDTORequest; +import dev.flima.application.educations.dtos.response.EducationDTOResponse; +import dev.flima.domain.educations.Education; +import dev.flima.domain.educations.EducationRepository; +import dev.flima.domain.exceptions.EntityNotFoundException; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; +import jakarta.ws.rs.NotFoundException; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class UpdateEducationUseCase { + + private final EducationRepository educationRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public UpdateEducationUseCase(EducationRepository educationRepository) { + this.educationRepository = educationRepository; + } + + @Transactional + public EducationDTOResponse execute(UUID id, EducationDTORequest educationDTO) { + Education education = educationRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("education.not_found"))); + + education.setTypeEducation(educationDTO.typeEducation()); + education.setDegree(educationDTO.degree()); + education.setTitle(educationDTO.title()); + education.setInstitution(educationDTO.institution()); + education.setPeriod(educationDTO.period()); + education.setSpecialization(educationDTO.specialization()); + education.setSkills(educationDTO.skills()); + education.setArchitectures(educationDTO.architectures()); + + educationRepository.modify(education); + + return new EducationDTOResponse( + education.getId(), + education.getTypeEducation(), + education.getDegree(), + education.getTitle(), + education.getInstitution(), + education.getPeriod(), + education.getSpecialization(), + education.getSkills(), + education.getArchitectures() + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/experiences/dtos/request/ExperienceDTORequest.java b/backend/src/main/java/dev/flima/application/experiences/dtos/request/ExperienceDTORequest.java new file mode 100644 index 0000000..fb12617 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/experiences/dtos/request/ExperienceDTORequest.java @@ -0,0 +1,27 @@ +package dev.flima.application.experiences.dtos.request; + +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotEmpty; +import jakarta.validation.constraints.NotNull; + +import java.util.List; + +public record ExperienceDTORequest( + @NotNull(message = "{title.not_null_or_empty}") + @NotBlank(message = "{title.not_null_or_empty}") + String title, + + @NotNull(message = "{experience.company.not_null}") + @NotBlank(message = "{experience.company.not_null}") + String company, + + @NotNull(message = "{period.not_null_or_empty}") + @NotBlank(message = "{period.not_null_or_empty}") + String period, + + @NotNull(message = "{experience.bullets.not_null}") + @NotEmpty(message = "{experience.bullets.not_null}") + Listbullets, + List technologies, + String icon +) {} diff --git a/backend/src/main/java/dev/flima/application/experiences/dtos/response/CreateExperienceDTOResponse.java b/backend/src/main/java/dev/flima/application/experiences/dtos/response/CreateExperienceDTOResponse.java new file mode 100644 index 0000000..4ee5a02 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/experiences/dtos/response/CreateExperienceDTOResponse.java @@ -0,0 +1,8 @@ +package dev.flima.application.experiences.dtos.response; + +import java.util.UUID; + +public record CreateExperienceDTOResponse( + UUID id, + String title +) {} diff --git a/backend/src/main/java/dev/flima/application/experiences/dtos/response/ExperienceDTOResponse.java b/backend/src/main/java/dev/flima/application/experiences/dtos/response/ExperienceDTOResponse.java new file mode 100644 index 0000000..4c040d3 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/experiences/dtos/response/ExperienceDTOResponse.java @@ -0,0 +1,14 @@ +package dev.flima.application.experiences.dtos.response; + +import java.util.List; +import java.util.UUID; + +public record ExperienceDTOResponse( + UUID id, + String title, + String company, + String period, + List bullets, + List technologies, + String icon +) {} diff --git a/backend/src/main/java/dev/flima/application/experiences/usecases/CreateExperienceUseCase.java b/backend/src/main/java/dev/flima/application/experiences/usecases/CreateExperienceUseCase.java new file mode 100644 index 0000000..400d465 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/experiences/usecases/CreateExperienceUseCase.java @@ -0,0 +1,38 @@ +package dev.flima.application.experiences.usecases; + +import dev.flima.application.experiences.dtos.request.ExperienceDTORequest; +import dev.flima.application.experiences.dtos.response.CreateExperienceDTOResponse; +import dev.flima.domain.experience.Experience; +import dev.flima.domain.experience.ExperienceRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; + +@ApplicationScoped +public class CreateExperienceUseCase { + + private final ExperienceRepository experienceRepository; + + public CreateExperienceUseCase(ExperienceRepository experienceRepository) { + this.experienceRepository = experienceRepository; + } + + @Transactional + public CreateExperienceDTOResponse execute(ExperienceDTORequest experienceDTO) { + Experience experience = new Experience( + experienceDTO.title(), + experienceDTO.company(), + experienceDTO.period(), + experienceDTO.bullets(), + experienceDTO.technologies(), + experienceDTO.icon() + ); + + experienceRepository.save(experience); + + return new CreateExperienceDTOResponse( + experience.getId(), + experience.getTitle() + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/experiences/usecases/DeleteExperienceUseCase.java b/backend/src/main/java/dev/flima/application/experiences/usecases/DeleteExperienceUseCase.java new file mode 100644 index 0000000..160a1a6 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/experiences/usecases/DeleteExperienceUseCase.java @@ -0,0 +1,30 @@ +package dev.flima.application.experiences.usecases; + +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.experience.Experience; +import dev.flima.domain.experience.ExperienceRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class DeleteExperienceUseCase { + + private final ExperienceRepository experienceRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public DeleteExperienceUseCase(ExperienceRepository experienceRepository) { + this.experienceRepository = experienceRepository; + } + + @Transactional + public void execute(UUID id) { + Experience experience = experienceRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("experience.not_found"))); + + experienceRepository.remove(experience); + } + +} diff --git a/backend/src/main/java/dev/flima/application/experiences/usecases/GetAllExperienceUseCase.java b/backend/src/main/java/dev/flima/application/experiences/usecases/GetAllExperienceUseCase.java new file mode 100644 index 0000000..c6eb07d --- /dev/null +++ b/backend/src/main/java/dev/flima/application/experiences/usecases/GetAllExperienceUseCase.java @@ -0,0 +1,34 @@ +package dev.flima.application.experiences.usecases; + +import dev.flima.application.experiences.dtos.response.ExperienceDTOResponse; +import dev.flima.domain.experience.Experience; +import dev.flima.domain.experience.ExperienceRepository; +import jakarta.enterprise.context.ApplicationScoped; + +import java.util.List; + +@ApplicationScoped +public class GetAllExperienceUseCase { + + private final ExperienceRepository experienceRepository; + + public GetAllExperienceUseCase(ExperienceRepository experienceRepository) { + this.experienceRepository = experienceRepository; + } + + public List execute() { + List experiences = experienceRepository.getAll(); + return experiences.stream() + .map(experience -> new ExperienceDTOResponse( + experience.getId(), + experience.getTitle(), + experience.getCompany(), + experience.getPeriod(), + experience.getBullets(), + experience.getTechnologies(), + experience.getIcon() + )) + .toList(); + } + +} diff --git a/backend/src/main/java/dev/flima/application/experiences/usecases/GetExperienceUseCase.java b/backend/src/main/java/dev/flima/application/experiences/usecases/GetExperienceUseCase.java new file mode 100644 index 0000000..1084d97 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/experiences/usecases/GetExperienceUseCase.java @@ -0,0 +1,38 @@ +package dev.flima.application.experiences.usecases; + +import dev.flima.application.experiences.dtos.response.ExperienceDTOResponse; +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.experience.Experience; +import dev.flima.domain.experience.ExperienceRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.ws.rs.NotFoundException; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class GetExperienceUseCase { + + private final ExperienceRepository experienceRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public GetExperienceUseCase(ExperienceRepository experienceRepository) { + this.experienceRepository = experienceRepository; + } + + public ExperienceDTOResponse execute(UUID id) { + Experience experience = this.experienceRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("experience.not_found"))); + + return new ExperienceDTOResponse( + experience.getId(), + experience.getTitle(), + experience.getCompany(), + experience.getPeriod(), + experience.getBullets(), + experience.getTechnologies(), + experience.getIcon() + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/experiences/usecases/UpdateExperienceUseCase.java b/backend/src/main/java/dev/flima/application/experiences/usecases/UpdateExperienceUseCase.java new file mode 100644 index 0000000..bce2047 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/experiences/usecases/UpdateExperienceUseCase.java @@ -0,0 +1,49 @@ +package dev.flima.application.experiences.usecases; + +import dev.flima.application.experiences.dtos.request.ExperienceDTORequest; +import dev.flima.application.experiences.dtos.response.ExperienceDTOResponse; +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.experience.Experience; +import dev.flima.domain.experience.ExperienceRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class UpdateExperienceUseCase { + + private final ExperienceRepository experienceRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public UpdateExperienceUseCase(ExperienceRepository experienceRepository) { + this.experienceRepository = experienceRepository; + } + + @Transactional + public ExperienceDTOResponse execute(UUID id, ExperienceDTORequest experienceDTO) { + Experience experience = experienceRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("experience.not_found"))); + + experience.setTitle(experienceDTO.title()); + experience.setCompany(experienceDTO.company()); + experience.setPeriod(experienceDTO.period()); + experience.setBullets(experienceDTO.bullets()); + experience.setTechnologies(experienceDTO.technologies()); + experience.setIcon(experienceDTO.icon()); + + experienceRepository.modify(experience); + + return new ExperienceDTOResponse( + experience.getId(), + experience.getTitle(), + experience.getCompany(), + experience.getPeriod(), + experience.getBullets(), + experience.getTechnologies(), + experience.getIcon() + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/messages/dtos/request/MessageDTORequest.java b/backend/src/main/java/dev/flima/application/messages/dtos/request/MessageDTORequest.java new file mode 100644 index 0000000..9b70fa4 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/messages/dtos/request/MessageDTORequest.java @@ -0,0 +1,24 @@ +package dev.flima.application.messages.dtos.request; + +import jakarta.validation.constraints.Email; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; + +public record MessageDTORequest ( + @NotNull(message = "{username.not_null}") + @NotBlank(message = "{username.not_null}") + String username, + + @NotNull(message = "{email.not_null}") + @NotBlank(message = "{email.not_null}") + @Email(message = "{email.invalid}") + String email, + + @NotNull(message = "{message.subject.not_null}") + @NotBlank(message = "{message.subject.not_null}") + String subject, + + @NotNull(message = "{message.message.not_null}") + @NotBlank(message = "{message.message.not_null}") + String message +){} diff --git a/backend/src/main/java/dev/flima/application/messages/dtos/request/RepliedMessageDTORequest.java b/backend/src/main/java/dev/flima/application/messages/dtos/request/RepliedMessageDTORequest.java new file mode 100644 index 0000000..4160c87 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/messages/dtos/request/RepliedMessageDTORequest.java @@ -0,0 +1,20 @@ +package dev.flima.application.messages.dtos.request; + +import jakarta.validation.constraints.Email; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; + +public record RepliedMessageDTORequest( + @NotNull(message = "{email.not_null}") + @NotBlank(message = "{email.not_null}") + @Email(message = "{email.invalid}") + String email, + + @NotNull(message = "{message.subject.not_null}") + @NotBlank(message = "{message.subject.not_null}") + String subject, + + @NotNull(message = "{message.message.not_null}") + @NotBlank(message = "{message.message.not_null}") + String message +) {} diff --git a/backend/src/main/java/dev/flima/application/messages/dtos/response/MessageDTOResponse.java b/backend/src/main/java/dev/flima/application/messages/dtos/response/MessageDTOResponse.java new file mode 100644 index 0000000..95637bf --- /dev/null +++ b/backend/src/main/java/dev/flima/application/messages/dtos/response/MessageDTOResponse.java @@ -0,0 +1,16 @@ +package dev.flima.application.messages.dtos.response; + +import dev.flima.domain.messages.StatusMessage; + +import java.time.LocalDateTime; +import java.util.UUID; + +public record MessageDTOResponse( + UUID id, + String username, + String email, + String message, + String subject, + LocalDateTime timestamp, + StatusMessage statusMessage +) {} diff --git a/backend/src/main/java/dev/flima/application/messages/usecases/CreateMessageUseCase.java b/backend/src/main/java/dev/flima/application/messages/usecases/CreateMessageUseCase.java new file mode 100644 index 0000000..9574799 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/messages/usecases/CreateMessageUseCase.java @@ -0,0 +1,30 @@ +package dev.flima.application.messages.usecases; + +import dev.flima.application.messages.dtos.request.MessageDTORequest; +import dev.flima.domain.messages.Message; +import dev.flima.domain.messages.MessageProducerPort; +import dev.flima.domain.messages.MessageRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; + +@ApplicationScoped +public class CreateMessageUseCase { + + private MessageProducerPort messageProducer; + + public CreateMessageUseCase(MessageProducerPort messageProducer) { + this.messageProducer = messageProducer; + } + + public void execute(MessageDTORequest messageDTO) { + Message message = new Message( + messageDTO.username(), + messageDTO.email(), + messageDTO.subject(), + messageDTO.message() + ); + + messageProducer.sendMessage(message); + } + +} diff --git a/backend/src/main/java/dev/flima/application/messages/usecases/DeleteMessaUseCase.java b/backend/src/main/java/dev/flima/application/messages/usecases/DeleteMessaUseCase.java new file mode 100644 index 0000000..6355cdb --- /dev/null +++ b/backend/src/main/java/dev/flima/application/messages/usecases/DeleteMessaUseCase.java @@ -0,0 +1,30 @@ +package dev.flima.application.messages.usecases; + +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.messages.Message; +import dev.flima.domain.messages.MessageRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class DeleteMessaUseCase { + + private final MessageRepository messageRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public DeleteMessaUseCase(MessageRepository messageRepository) { + this.messageRepository = messageRepository; + } + + @Transactional + public void execute(UUID id) { + Message message = messageRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("message.not_found"))); + + messageRepository.remove(message); + } + +} diff --git a/backend/src/main/java/dev/flima/application/messages/usecases/GetAllMessageUseCase.java b/backend/src/main/java/dev/flima/application/messages/usecases/GetAllMessageUseCase.java new file mode 100644 index 0000000..399dc77 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/messages/usecases/GetAllMessageUseCase.java @@ -0,0 +1,34 @@ +package dev.flima.application.messages.usecases; + +import dev.flima.application.messages.dtos.response.MessageDTOResponse; +import dev.flima.domain.messages.Message; +import dev.flima.domain.messages.MessageRepository; +import jakarta.enterprise.context.ApplicationScoped; + +import java.util.List; + +@ApplicationScoped +public class GetAllMessageUseCase { + + private final MessageRepository messageRepository; + + public GetAllMessageUseCase(MessageRepository messageRepository) { + this.messageRepository = messageRepository; + } + + public List execute() { + List messages = messageRepository.getAll(); + return messages.stream() + .map(message -> new MessageDTOResponse( + message.getId(), + message.getUsername(), + message.getEmail(), + message.getMessage(), + message.getSubject(), + message.getTimestamp(), + message.getStatusMessage() + )) + .toList(); + } + +} diff --git a/backend/src/main/java/dev/flima/application/messages/usecases/GetMessageUseCase.java b/backend/src/main/java/dev/flima/application/messages/usecases/GetMessageUseCase.java new file mode 100644 index 0000000..b840726 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/messages/usecases/GetMessageUseCase.java @@ -0,0 +1,39 @@ +package dev.flima.application.messages.usecases; + +import dev.flima.application.messages.dtos.response.MessageDTOResponse; +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.messages.Message; +import dev.flima.domain.messages.MessageRepository; +import dev.flima.domain.messages.StatusMessage; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.ws.rs.NotFoundException; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class GetMessageUseCase { + + private final MessageRepository messageRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public GetMessageUseCase(MessageRepository messageRepository) { + this.messageRepository = messageRepository; + } + + public MessageDTOResponse execute(UUID id) { + Message message = messageRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("message.not_found"))); + + return new MessageDTOResponse( + message.getId(), + message.getUsername(), + message.getEmail(), + message.getMessage(), + message.getSubject(), + message.getTimestamp(), + message.getStatusMessage() + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/messages/usecases/PersistMessageUseCase.java b/backend/src/main/java/dev/flima/application/messages/usecases/PersistMessageUseCase.java new file mode 100644 index 0000000..67f60bc --- /dev/null +++ b/backend/src/main/java/dev/flima/application/messages/usecases/PersistMessageUseCase.java @@ -0,0 +1,22 @@ +package dev.flima.application.messages.usecases; + +import dev.flima.domain.messages.Message; +import dev.flima.domain.messages.MessageRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; + +@ApplicationScoped +public class PersistMessageUseCase { + + private final MessageRepository messageRepository; + + public PersistMessageUseCase(MessageRepository messageRepository) { + this.messageRepository = messageRepository; + } + + @Transactional + public void execute(Message message) { + messageRepository.save(message); + } + +} diff --git a/backend/src/main/java/dev/flima/application/messages/usecases/ReadMessageUseCase.java b/backend/src/main/java/dev/flima/application/messages/usecases/ReadMessageUseCase.java new file mode 100644 index 0000000..fb28ee3 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/messages/usecases/ReadMessageUseCase.java @@ -0,0 +1,37 @@ +package dev.flima.application.messages.usecases; + +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.messages.Message; +import dev.flima.domain.messages.MessageRepository; +import dev.flima.domain.messages.StatusMessage; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; +import jakarta.ws.rs.NotFoundException; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class ReadMessageUseCase { + + private final MessageRepository messageRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public ReadMessageUseCase(MessageRepository messageRepository) { + this.messageRepository = messageRepository; + } + + @Transactional + public void execute(UUID id) { + Message message = messageRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("message.not_found"))); + + if(!message.getStatusMessage().equals(StatusMessage.UNREAD)) { + throw new EntityNotFoundException(messages.getString("message.status_message.not_null")); + } + + message.setStatusMessage(StatusMessage.READ); + messageRepository.modify(message); + } + +} diff --git a/backend/src/main/java/dev/flima/application/messages/usecases/RepliedMessageUseCase.java b/backend/src/main/java/dev/flima/application/messages/usecases/RepliedMessageUseCase.java new file mode 100644 index 0000000..1bff279 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/messages/usecases/RepliedMessageUseCase.java @@ -0,0 +1,66 @@ +package dev.flima.application.messages.usecases; + +import dev.flima.application.messages.dtos.request.RepliedMessageDTORequest; +import dev.flima.domain.exceptions.BusinessRuleException; +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.messages.Message; +import dev.flima.domain.messages.MessageProducerPort; +import dev.flima.domain.messages.MessageRepository; +import dev.flima.domain.messages.StatusMessage; +import io.quarkus.mailer.Mail; +import io.quarkus.mailer.Mailer; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; +import jakarta.ws.rs.NotFoundException; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class RepliedMessageUseCase { + + private final MessageRepository messageRepository; + private final MessageProducerPort messageProducer; + private final Mailer mailer; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public RepliedMessageUseCase(MessageRepository messageRepository, MessageProducerPort messageProducer, Mailer mailer) { + this.messageRepository = messageRepository; + this.messageProducer = messageProducer; + this.mailer = mailer; + } + + @Transactional + public void execute(UUID id, RepliedMessageDTORequest request) { + Message message = messageRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("message.not_found"))); + + if(message.getStatusMessage().equals(StatusMessage.REPLIED)) { + throw new BusinessRuleException(messages.getString("message.invalid_status_for_reply")); + } + + Message myMessage = new Message( + "flima.dev", + request.email(), + String.format("Response payload for: %s", message.getSubject()), + request.message() + ); + + try { + mailer.send(Mail.withText( + request.email(), + String.format("Response payload for: %s", message.getSubject()), + request.message() + )); + + messageProducer.sendMessage(myMessage); + } catch (Exception e) { + throw new BusinessRuleException(messages.getString("message.trying.reply")); + } + + message.setStatusMessage(StatusMessage.REPLIED); + + messageRepository.modify(message); + } + +} diff --git a/backend/src/main/java/dev/flima/application/projects/dtos/request/ProjectDTORequest.java b/backend/src/main/java/dev/flima/application/projects/dtos/request/ProjectDTORequest.java new file mode 100644 index 0000000..e6fa50e --- /dev/null +++ b/backend/src/main/java/dev/flima/application/projects/dtos/request/ProjectDTORequest.java @@ -0,0 +1,24 @@ +package dev.flima.application.projects.dtos.request; + +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; + +import java.util.List; + +public record ProjectDTORequest( + @NotNull(message = "{title.not_null_or_empty}") + @NotBlank(message = "{title.not_null_or_empty}") + String title, + + @NotNull(message = "{subtitle.not_null_or_empty}") + @NotBlank(message = "{subtitle.not_null_or_empty}") + String subtitle, + + @NotNull(message = "{project.description.not_null}") + @NotBlank(message = "{project.description.not_null}") + String description, + + Listtechnologies, + String codeSnippet, + String icon +) {} diff --git a/backend/src/main/java/dev/flima/application/projects/dtos/response/CreateProjectDTOResponse.java b/backend/src/main/java/dev/flima/application/projects/dtos/response/CreateProjectDTOResponse.java new file mode 100644 index 0000000..4947e5e --- /dev/null +++ b/backend/src/main/java/dev/flima/application/projects/dtos/response/CreateProjectDTOResponse.java @@ -0,0 +1,8 @@ +package dev.flima.application.projects.dtos.response; + +import java.util.UUID; + +public record CreateProjectDTOResponse( + UUID id, + String title +) {} diff --git a/backend/src/main/java/dev/flima/application/projects/dtos/response/ProjectDTOResponse.java b/backend/src/main/java/dev/flima/application/projects/dtos/response/ProjectDTOResponse.java new file mode 100644 index 0000000..3032fdd --- /dev/null +++ b/backend/src/main/java/dev/flima/application/projects/dtos/response/ProjectDTOResponse.java @@ -0,0 +1,14 @@ +package dev.flima.application.projects.dtos.response; + +import java.util.List; +import java.util.UUID; + +public record ProjectDTOResponse( + UUID id, + String title, + String subtitle, + String description, + List technologies, + String codeSnippet, + String icon +) {} diff --git a/backend/src/main/java/dev/flima/application/projects/usecases/CreateProjectUseCase.java b/backend/src/main/java/dev/flima/application/projects/usecases/CreateProjectUseCase.java new file mode 100644 index 0000000..ba77794 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/projects/usecases/CreateProjectUseCase.java @@ -0,0 +1,38 @@ +package dev.flima.application.projects.usecases; + +import dev.flima.application.projects.dtos.request.ProjectDTORequest; +import dev.flima.application.projects.dtos.response.CreateProjectDTOResponse; +import dev.flima.domain.projects.Project; +import dev.flima.domain.projects.ProjectRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; + +@ApplicationScoped +public class CreateProjectUseCase { + + private final ProjectRepository projectRepository; + + public CreateProjectUseCase(ProjectRepository projectRepository) { + this.projectRepository = projectRepository; + } + + @Transactional + public CreateProjectDTOResponse execute(ProjectDTORequest projectDTO) { + Project project = new Project( + projectDTO.title(), + projectDTO.subtitle(), + projectDTO.description(), + projectDTO.technologies(), + projectDTO.codeSnippet(), + projectDTO.icon() + ); + + projectRepository.save(project); + + return new CreateProjectDTOResponse( + project.getId(), + project.getTitle() + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/projects/usecases/DeleteProjectUseCase.java b/backend/src/main/java/dev/flima/application/projects/usecases/DeleteProjectUseCase.java new file mode 100644 index 0000000..9744ed2 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/projects/usecases/DeleteProjectUseCase.java @@ -0,0 +1,29 @@ +package dev.flima.application.projects.usecases; + +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.projects.Project; +import dev.flima.domain.projects.ProjectRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class DeleteProjectUseCase { + + private final ProjectRepository projectRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public DeleteProjectUseCase(ProjectRepository projectRepository) { + this.projectRepository = projectRepository; + } + + @Transactional + public void execute(UUID id) { + Project project = this.projectRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("project.not_found"))); + + projectRepository.remove(project); + } +} diff --git a/backend/src/main/java/dev/flima/application/projects/usecases/GetAllProjectsUseCase.java b/backend/src/main/java/dev/flima/application/projects/usecases/GetAllProjectsUseCase.java new file mode 100644 index 0000000..fc0da54 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/projects/usecases/GetAllProjectsUseCase.java @@ -0,0 +1,31 @@ +package dev.flima.application.projects.usecases; + +import dev.flima.application.projects.dtos.response.ProjectDTOResponse; +import dev.flima.domain.projects.ProjectRepository; +import jakarta.enterprise.context.ApplicationScoped; + +import java.util.List; + +@ApplicationScoped +public class GetAllProjectsUseCase { + + private final ProjectRepository projectRepository; + + public GetAllProjectsUseCase(ProjectRepository projectRepository) { + this.projectRepository = projectRepository; + } + + public List execute() { + return projectRepository.getAll().stream() + .map(project -> new ProjectDTOResponse( + project.getId(), + project.getTitle(), + project.getSubtitle(), + project.getDescription(), + project.getTechnologies(), + project.getCodeSnippet(), + project.getIcon() + )).toList(); + } + +} diff --git a/backend/src/main/java/dev/flima/application/projects/usecases/GetProjectUseCase.java b/backend/src/main/java/dev/flima/application/projects/usecases/GetProjectUseCase.java new file mode 100644 index 0000000..b1c78d0 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/projects/usecases/GetProjectUseCase.java @@ -0,0 +1,37 @@ +package dev.flima.application.projects.usecases; + +import dev.flima.application.projects.dtos.response.ProjectDTOResponse; +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.projects.Project; +import dev.flima.domain.projects.ProjectRepository; +import jakarta.enterprise.context.ApplicationScoped; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class GetProjectUseCase { + + private final ProjectRepository projectRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public GetProjectUseCase(ProjectRepository projectRepository) { + this.projectRepository = projectRepository; + } + + public ProjectDTOResponse execute(UUID id) { + Project project = projectRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("project.not_found"))); + + return new ProjectDTOResponse( + project.getId(), + project.getTitle(), + project.getSubtitle(), + project.getDescription(), + project.getTechnologies(), + project.getCodeSnippet(), + project.getIcon() + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/projects/usecases/UpdateProjectUseCase.java b/backend/src/main/java/dev/flima/application/projects/usecases/UpdateProjectUseCase.java new file mode 100644 index 0000000..ea9a00d --- /dev/null +++ b/backend/src/main/java/dev/flima/application/projects/usecases/UpdateProjectUseCase.java @@ -0,0 +1,49 @@ +package dev.flima.application.projects.usecases; + +import dev.flima.application.projects.dtos.request.ProjectDTORequest; +import dev.flima.application.projects.dtos.response.ProjectDTOResponse; +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.projects.Project; +import dev.flima.domain.projects.ProjectRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class UpdateProjectUseCase { + + private final ProjectRepository projectRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public UpdateProjectUseCase(ProjectRepository projectRepository) { + this.projectRepository = projectRepository; + } + + @Transactional + public ProjectDTOResponse execute(UUID id, ProjectDTORequest projectDTO) { + Project project = projectRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("project.not_found"))); + + project.setTitle(projectDTO.title()); + project.setSubtitle(projectDTO.subtitle()); + project.setDescription(projectDTO.description()); + project.setTechnologies(projectDTO.technologies()); + project.setCodeSnippet(projectDTO.codeSnippet()); + project.setIcon(projectDTO.icon()); + + projectRepository.modify(project); + + return new ProjectDTOResponse( + project.getId(), + project.getTitle(), + project.getSubtitle(), + project.getDescription(), + project.getTechnologies(), + project.getCodeSnippet(), + project.getIcon() + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/stacks/dtos/request/StackDTORequest.java b/backend/src/main/java/dev/flima/application/stacks/dtos/request/StackDTORequest.java new file mode 100644 index 0000000..9c2b9fa --- /dev/null +++ b/backend/src/main/java/dev/flima/application/stacks/dtos/request/StackDTORequest.java @@ -0,0 +1,17 @@ +package dev.flima.application.stacks.dtos.request; + +import dev.flima.domain.stacks.StackType; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotEmpty; +import jakarta.validation.constraints.NotNull; + +import java.util.List; + +public record StackDTORequest( + @NotNull(message = "{stack.stack_type.not_null}") + StackType stackType, + + @NotNull(message = "{technologies.not_null_or_empty}") + @NotEmpty(message = "{technologies.not_null_or_empty}") + List technologies +) {} diff --git a/backend/src/main/java/dev/flima/application/stacks/dtos/response/CreateStackDTOResponse.java b/backend/src/main/java/dev/flima/application/stacks/dtos/response/CreateStackDTOResponse.java new file mode 100644 index 0000000..b925d8a --- /dev/null +++ b/backend/src/main/java/dev/flima/application/stacks/dtos/response/CreateStackDTOResponse.java @@ -0,0 +1,7 @@ +package dev.flima.application.stacks.dtos.response; + +import java.util.UUID; + +public record CreateStackDTOResponse( + UUID id +) {} diff --git a/backend/src/main/java/dev/flima/application/stacks/dtos/response/StackDTOResponse.java b/backend/src/main/java/dev/flima/application/stacks/dtos/response/StackDTOResponse.java new file mode 100644 index 0000000..1b6ca1c --- /dev/null +++ b/backend/src/main/java/dev/flima/application/stacks/dtos/response/StackDTOResponse.java @@ -0,0 +1,12 @@ +package dev.flima.application.stacks.dtos.response; + +import dev.flima.domain.stacks.StackType; + +import java.util.List; +import java.util.UUID; + +public record StackDTOResponse( + UUID id, + StackType stackType, + List technologies +) {} diff --git a/backend/src/main/java/dev/flima/application/stacks/usecases/CreateStackUseCase.java b/backend/src/main/java/dev/flima/application/stacks/usecases/CreateStackUseCase.java new file mode 100644 index 0000000..ed54d01 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/stacks/usecases/CreateStackUseCase.java @@ -0,0 +1,30 @@ +package dev.flima.application.stacks.usecases; + +import dev.flima.application.stacks.dtos.request.StackDTORequest; +import dev.flima.application.stacks.dtos.response.CreateStackDTOResponse; +import dev.flima.domain.stacks.Stack; +import dev.flima.domain.stacks.StackRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; + +@ApplicationScoped +public class CreateStackUseCase { + + private final StackRepository stackRepository; + + public CreateStackUseCase(StackRepository stackRepository) { + this.stackRepository = stackRepository; + } + + @Transactional + public CreateStackDTOResponse execute(StackDTORequest stackDTO) { + Stack stack = new Stack(stackDTO.stackType(), stackDTO.technologies()); + + stackRepository.save(stack); + + return new CreateStackDTOResponse( + stack.getId() + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/stacks/usecases/DeleteStackUseCase.java b/backend/src/main/java/dev/flima/application/stacks/usecases/DeleteStackUseCase.java new file mode 100644 index 0000000..f54f533 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/stacks/usecases/DeleteStackUseCase.java @@ -0,0 +1,30 @@ +package dev.flima.application.stacks.usecases; + +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.stacks.Stack; +import dev.flima.domain.stacks.StackRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class DeleteStackUseCase { + + private final StackRepository stackRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public DeleteStackUseCase(StackRepository stackRepository) { + this.stackRepository = stackRepository; + } + + @Transactional + public void execute(UUID id) { + Stack stack = stackRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("stack.not_found"))); + + stackRepository.remove(stack); + } + +} diff --git a/backend/src/main/java/dev/flima/application/stacks/usecases/GetAllStackUseCase.java b/backend/src/main/java/dev/flima/application/stacks/usecases/GetAllStackUseCase.java new file mode 100644 index 0000000..0001b0a --- /dev/null +++ b/backend/src/main/java/dev/flima/application/stacks/usecases/GetAllStackUseCase.java @@ -0,0 +1,30 @@ +package dev.flima.application.stacks.usecases; + +import dev.flima.application.stacks.dtos.response.StackDTOResponse; +import dev.flima.domain.stacks.Stack; +import dev.flima.domain.stacks.StackRepository; +import jakarta.enterprise.context.ApplicationScoped; + +import java.util.List; + +@ApplicationScoped +public class GetAllStackUseCase { + + private final StackRepository stackRepository; + + public GetAllStackUseCase(StackRepository stackRepository) { + this.stackRepository = stackRepository; + } + + public List execute() { + List stacks = stackRepository.getAll(); + + return stacks.stream() + .map(stack -> new StackDTOResponse( + stack.getId(), + stack.getStackType(), + stack.getTechnologies() + )) + .toList(); + } +} diff --git a/backend/src/main/java/dev/flima/application/stacks/usecases/GetStackUseCase.java b/backend/src/main/java/dev/flima/application/stacks/usecases/GetStackUseCase.java new file mode 100644 index 0000000..a67394b --- /dev/null +++ b/backend/src/main/java/dev/flima/application/stacks/usecases/GetStackUseCase.java @@ -0,0 +1,32 @@ +package dev.flima.application.stacks.usecases; + +import dev.flima.application.stacks.dtos.response.StackDTOResponse; +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.stacks.Stack; +import dev.flima.domain.stacks.StackRepository; +import jakarta.enterprise.context.ApplicationScoped; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class GetStackUseCase { + + private final StackRepository stackRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public GetStackUseCase(StackRepository stackRepository) { + this.stackRepository = stackRepository; + } + + public StackDTOResponse execute(UUID id) { + Stack stack = stackRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("stack.not_found"))); + + return new StackDTOResponse( + stack.getId(), + stack.getStackType(), + stack.getTechnologies() + ); + } +} diff --git a/backend/src/main/java/dev/flima/application/stacks/usecases/UpdateStackUseCase.java b/backend/src/main/java/dev/flima/application/stacks/usecases/UpdateStackUseCase.java new file mode 100644 index 0000000..d140f47 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/stacks/usecases/UpdateStackUseCase.java @@ -0,0 +1,41 @@ +package dev.flima.application.stacks.usecases; + +import dev.flima.application.stacks.dtos.request.StackDTORequest; +import dev.flima.application.stacks.dtos.response.StackDTOResponse; +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.stacks.Stack; +import dev.flima.domain.stacks.StackRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class UpdateStackUseCase { + + private final StackRepository stackRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public UpdateStackUseCase(StackRepository stackRepository) { + this.stackRepository = stackRepository; + } + + @Transactional + public StackDTOResponse execute(UUID id, StackDTORequest stackDTO) { + Stack stack = stackRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("stack.not_found"))); + + stack.setStackType(stackDTO.stackType()); + stack.setTechnologies(stackDTO.technologies()); + + stackRepository.modify(stack); + + return new StackDTOResponse( + stack.getId(), + stack.getStackType(), + stack.getTechnologies() + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/stats/dtos/request/StatDTORequest.java b/backend/src/main/java/dev/flima/application/stats/dtos/request/StatDTORequest.java new file mode 100644 index 0000000..c0b5198 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/stats/dtos/request/StatDTORequest.java @@ -0,0 +1,28 @@ +package dev.flima.application.stats.dtos.request; + +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; + +public record StatDTORequest( + @NotNull(message = "{stat.years_experience.not_null}") + @NotBlank(message = "{stat.years_experience.not_null}") + String yearsExperience, + + @NotNull(message = "{stat.system_deployed.not_null}") + @NotBlank(message = "{stat.system_deployed.not_null}") + String systemDeployed, + + @NotNull(message = "{stat.uptime_sla.not_null}") + @NotBlank(message = "{stat.uptime_sla.not_null}") + String uptimeSLA, + + @NotNull(message = "{stat.commits_logged.not_null}") + @NotBlank(message = "{stat.commits_logged.not_null}") + String commitsLogged, + + @NotNull(message = "{stat.status.not_null}") + @NotBlank(message = "{stat.status.not_null}") + String status, + + String objective +) {} diff --git a/backend/src/main/java/dev/flima/application/stats/dtos/response/CreateStatDTOResponse.java b/backend/src/main/java/dev/flima/application/stats/dtos/response/CreateStatDTOResponse.java new file mode 100644 index 0000000..f643826 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/stats/dtos/response/CreateStatDTOResponse.java @@ -0,0 +1,7 @@ +package dev.flima.application.stats.dtos.response; + +import java.util.UUID; + +public record CreateStatDTOResponse( + UUID id +) {} diff --git a/backend/src/main/java/dev/flima/application/stats/dtos/response/StatDTOResponse.java b/backend/src/main/java/dev/flima/application/stats/dtos/response/StatDTOResponse.java new file mode 100644 index 0000000..b38ba5d --- /dev/null +++ b/backend/src/main/java/dev/flima/application/stats/dtos/response/StatDTOResponse.java @@ -0,0 +1,13 @@ +package dev.flima.application.stats.dtos.response; + +import java.util.UUID; + +public record StatDTOResponse( + UUID id, + String yearsExperience, + String systemDeployed, + String uptimeSLA, + String commitsLogged, + String status, + String objective +) {} diff --git a/backend/src/main/java/dev/flima/application/stats/usecases/CreateStatUseCase.java b/backend/src/main/java/dev/flima/application/stats/usecases/CreateStatUseCase.java new file mode 100644 index 0000000..7d6b42a --- /dev/null +++ b/backend/src/main/java/dev/flima/application/stats/usecases/CreateStatUseCase.java @@ -0,0 +1,37 @@ +package dev.flima.application.stats.usecases; + +import dev.flima.application.stats.dtos.request.StatDTORequest; +import dev.flima.application.stats.dtos.response.CreateStatDTOResponse; +import dev.flima.domain.stats.Stat; +import dev.flima.domain.stats.StatRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; + +@ApplicationScoped +public class CreateStatUseCase { + + private final StatRepository statRepository; + + public CreateStatUseCase(StatRepository statRepository) { + this.statRepository = statRepository; + } + + @Transactional + public CreateStatDTOResponse execute(StatDTORequest statsDTO) { + Stat stat = new Stat( + statsDTO.yearsExperience(), + statsDTO.systemDeployed(), + statsDTO.uptimeSLA(), + statsDTO.commitsLogged(), + statsDTO.status(), + statsDTO.objective() + ); + + statRepository.save(stat); + + return new CreateStatDTOResponse( + stat.getId() + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/stats/usecases/DeleteStatUseCase.java b/backend/src/main/java/dev/flima/application/stats/usecases/DeleteStatUseCase.java new file mode 100644 index 0000000..df6f59a --- /dev/null +++ b/backend/src/main/java/dev/flima/application/stats/usecases/DeleteStatUseCase.java @@ -0,0 +1,31 @@ +package dev.flima.application.stats.usecases; + +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.stats.Stat; +import dev.flima.domain.stats.StatRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; +import jakarta.ws.rs.NotFoundException; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class DeleteStatUseCase { + + private final StatRepository statRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public DeleteStatUseCase(StatRepository statRepository) { + this.statRepository = statRepository; + } + + @Transactional + public void execute(UUID id) { + Stat stat = statRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("stat.not_found"))); + + statRepository.remove(stat); + } + +} diff --git a/backend/src/main/java/dev/flima/application/stats/usecases/GetAllStatUseCase.java b/backend/src/main/java/dev/flima/application/stats/usecases/GetAllStatUseCase.java new file mode 100644 index 0000000..97a9c79 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/stats/usecases/GetAllStatUseCase.java @@ -0,0 +1,33 @@ +package dev.flima.application.stats.usecases; + +import dev.flima.application.stats.dtos.response.StatDTOResponse; +import dev.flima.domain.stats.Stat; +import dev.flima.domain.stats.StatRepository; +import jakarta.enterprise.context.ApplicationScoped; + +import java.util.List; + +@ApplicationScoped +public class GetAllStatUseCase { + + private final StatRepository statRepository; + + public GetAllStatUseCase(StatRepository statRepository) { + this.statRepository = statRepository; + } + + public List execute() { + List entities = statRepository.getAll(); + return entities.stream() + .map(entity -> new StatDTOResponse( + entity.getId(), + entity.getYearsExperience(), + entity.getSystemDeployed(), + entity.getUptimeSLA(), + entity.getCommitsLogged(), + entity.getStatus(), + entity.getObjective() + )).toList(); + } + +} diff --git a/backend/src/main/java/dev/flima/application/stats/usecases/GetStatUseCase.java b/backend/src/main/java/dev/flima/application/stats/usecases/GetStatUseCase.java new file mode 100644 index 0000000..3b10e52 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/stats/usecases/GetStatUseCase.java @@ -0,0 +1,37 @@ +package dev.flima.application.stats.usecases; + +import dev.flima.application.stats.dtos.response.StatDTOResponse; +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.stats.Stat; +import dev.flima.domain.stats.StatRepository; +import jakarta.enterprise.context.ApplicationScoped; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class GetStatUseCase { + + private final StatRepository statRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public GetStatUseCase(StatRepository statRepository) { + this.statRepository = statRepository; + } + + public StatDTOResponse execute(UUID id) { + Stat stat = statRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("stat.not_found"))); + + return new StatDTOResponse( + stat.getId(), + stat.getYearsExperience(), + stat.getSystemDeployed(), + stat.getUptimeSLA(), + stat.getCommitsLogged(), + stat.getStatus(), + stat.getObjective() + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/stats/usecases/UpdateStatUseCase.java b/backend/src/main/java/dev/flima/application/stats/usecases/UpdateStatUseCase.java new file mode 100644 index 0000000..c2e1e22 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/stats/usecases/UpdateStatUseCase.java @@ -0,0 +1,49 @@ +package dev.flima.application.stats.usecases; + +import dev.flima.application.stats.dtos.request.StatDTORequest; +import dev.flima.application.stats.dtos.response.StatDTOResponse; +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.stats.Stat; +import dev.flima.domain.stats.StatRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; + +import java.util.ResourceBundle; +import java.util.UUID; + +@ApplicationScoped +public class UpdateStatUseCase { + + private final StatRepository statRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public UpdateStatUseCase(StatRepository statRepository) { + this.statRepository = statRepository; + } + + @Transactional + public StatDTOResponse execute(UUID id, StatDTORequest statsDTO) { + Stat stat = statRepository.getById(id) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("stat.not_found"))); + + stat.setYearsExperience(statsDTO.yearsExperience()); + stat.setSystemDeployed(statsDTO.systemDeployed()); + stat.setUptimeSLA(statsDTO.uptimeSLA()); + stat.setCommitsLogged(statsDTO.commitsLogged()); + stat.setStatus(statsDTO.status()); + stat.setObjective(statsDTO.objective()); + + statRepository.modify(stat); + + return new StatDTOResponse( + stat.getId(), + stat.getYearsExperience(), + stat.getSystemDeployed(), + stat.getUptimeSLA(), + stat.getCommitsLogged(), + stat.getStatus(), + stat.getObjective() + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/users/dtos/request/UserDTORequest.java b/backend/src/main/java/dev/flima/application/users/dtos/request/UserDTORequest.java new file mode 100644 index 0000000..582d466 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/users/dtos/request/UserDTORequest.java @@ -0,0 +1,33 @@ +package dev.flima.application.users.dtos.request; + +import dev.flima.domain.users.Password; +import dev.flima.domain.users.Role; +import jakarta.validation.Valid; +import jakarta.validation.constraints.Email; +import jakarta.validation.constraints.NotBlank; +import jakarta.validation.constraints.NotNull; + +public record UserDTORequest( + @NotNull(message = "{username.not_null}") + @NotBlank(message = "{username.not_null}") + String username, + + @NotNull(message = "{user.name.not_null}") + @NotBlank(message = "{user.name.not_null}") + String name, + + @NotNull(message = "{user.last_name.not_null}") + @NotBlank(message = "{user.last_name.not_null}") + String lastName, + + @NotNull(message = "{email.not_null}") + @NotBlank(message = "{email.not_null}") + @Email(message = "{email.invalid}") + String email, + + @NotNull(message = "{user.role.not_null}") + Role role, + + @Valid + Password password +) {} diff --git a/backend/src/main/java/dev/flima/application/users/dtos/response/UserDTOResponse.java b/backend/src/main/java/dev/flima/application/users/dtos/response/UserDTOResponse.java new file mode 100644 index 0000000..5a23640 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/users/dtos/response/UserDTOResponse.java @@ -0,0 +1,8 @@ +package dev.flima.application.users.dtos.response; + +import dev.flima.domain.users.Role; + +public record UserDTOResponse( + String username, + Role role +) {} diff --git a/backend/src/main/java/dev/flima/application/users/usecases/CreateUserUseCase.java b/backend/src/main/java/dev/flima/application/users/usecases/CreateUserUseCase.java new file mode 100644 index 0000000..56a7e2e --- /dev/null +++ b/backend/src/main/java/dev/flima/application/users/usecases/CreateUserUseCase.java @@ -0,0 +1,51 @@ +package dev.flima.application.users.usecases; + +import dev.flima.application.users.dtos.request.UserDTORequest; +import dev.flima.application.users.dtos.response.UserDTOResponse; +import dev.flima.domain.exceptions.BusinessRuleException; +import dev.flima.domain.security.PasswordHasher; +import dev.flima.domain.users.Password; +import dev.flima.domain.users.User; +import dev.flima.domain.users.UserRepository; +import jakarta.enterprise.context.ApplicationScoped; +import jakarta.transaction.Transactional; + +import java.util.UUID; + +@ApplicationScoped +public class CreateUserUseCase { + + private final UserRepository userRepository; + private final PasswordHasher passwordHasher; + + public CreateUserUseCase(UserRepository userRepository, PasswordHasher passwordHasher) { + this.userRepository = userRepository; + this.passwordHasher = passwordHasher; + } + + @Transactional + public UserDTOResponse execute(UserDTORequest userDTO) { + if (userRepository.count() > 0) { + throw new BusinessRuleException("System is already initialized. New registrations are disabled."); + } + String passwordHashed = passwordHasher.hash(new Password(userDTO.password().password())); + + User user = new User( + UUID.randomUUID(), + userDTO.username(), + userDTO.name(), + userDTO.lastName(), + userDTO.email(), + userDTO.role(), + new Password(passwordHashed) + ); + + userRepository.save(user); + + return new UserDTOResponse( + user.getUsername(), + user.getRole() + ); + } + +} diff --git a/backend/src/main/java/dev/flima/application/users/usecases/GetUserUseCase.java b/backend/src/main/java/dev/flima/application/users/usecases/GetUserUseCase.java new file mode 100644 index 0000000..b077af6 --- /dev/null +++ b/backend/src/main/java/dev/flima/application/users/usecases/GetUserUseCase.java @@ -0,0 +1,31 @@ +package dev.flima.application.users.usecases; + +import dev.flima.application.users.dtos.response.UserDTOResponse; +import dev.flima.domain.exceptions.EntityNotFoundException; +import dev.flima.domain.users.User; +import dev.flima.domain.users.UserRepository; +import jakarta.enterprise.context.ApplicationScoped; + +import java.util.ResourceBundle; + +@ApplicationScoped +public class GetUserUseCase { + + private final UserRepository userRepository; + private final ResourceBundle messages = ResourceBundle.getBundle("messages"); + + public GetUserUseCase(UserRepository userRepository) { + this.userRepository = userRepository; + } + + public UserDTOResponse execute(String username) { + User user = userRepository.getUsername(username) + .orElseThrow(() -> new EntityNotFoundException(messages.getString("user.not_found"))); + + return new UserDTOResponse( + user.getUsername(), + user.getRole() + ); + } + +}