Gustavo/FrontFocusAgenda
1
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Piroca doce

Browse Source
This commit is contained in:
Gustavo
2026-05-12 20:30:14 -03:00
commit 0e39524e00
57 changed files with 3774 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/main/java/com/agendaestudantil/AgendaDigitalEstudantesApplication.java
+12
View File
@@ -0,0 +1,12 @@
package com.agendaestudantil;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class AgendaDigitalEstudantesApplication {
public static void main(String[] args) {
SpringApplication.run(AgendaDigitalEstudantesApplication.class, args);
}
}
src/main/java/com/agendaestudantil/configuracao/ConfiguracaoMongo.java
+9
View File
@@ -0,0 +1,9 @@
package com.agendaestudantil.configuracao;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.config.EnableMongoAuditing;
@Configuration
@EnableMongoAuditing
public class ConfiguracaoMongo {
}
src/main/java/com/agendaestudantil/configuracao/ConfiguracaoSeguranca.java
+77
View File
@@ -0,0 +1,77 @@
package com.agendaestudantil.configuracao;
import com.agendaestudantil.filtro.FiltroJwt;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import java.util.List;
@Configuration
@EnableWebSecurity
public class ConfiguracaoSeguranca {
private final FiltroJwt filtroJwt;
private final String corsAllowedOrigins;
public ConfiguracaoSeguranca(FiltroJwt filtroJwt, @Value("${cors.allowed.origins}") String corsAllowedOrigins) {
this.filtroJwt = filtroJwt;
this.corsAllowedOrigins = corsAllowedOrigins;
}
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http.csrf(csrf -> csrf.disable())
.cors(cors -> cors.configurationSource(corsConfigurationSource()))
.authorizeHttpRequests(auth -> auth
.requestMatchers(
"/", "/index.html", "/login.html", "/cadastro.html",
"/favicon.ico", "/imagens/**",
"/*.css", "/*.js", "/*.ico", "/*.png",
"/api/estudantes/cadastro", "/api/estudantes/login",
"/swagger-ui/**", "/v3/api-docs/**")
.permitAll()
.anyRequest().authenticated())
.sessionManagement(session -> session
.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
.addFilterBefore(filtroJwt, UsernamePasswordAuthenticationFilter.class);
return http.build();
}
@Bean
public CorsConfigurationSource corsConfigurationSource() {
CorsConfiguration configuration = new CorsConfiguration();
configuration.setAllowedOrigins(List.of(corsAllowedOrigins.split(",")));
configuration.setAllowedMethods(List.of("GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"));
configuration.setAllowedHeaders(List.of("*"));
configuration.setExposedHeaders(List.of("Authorization"));
configuration.setAllowCredentials(true);
configuration.setMaxAge(3600L);
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/**", configuration);
return source;
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
@Bean
public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
return config.getAuthenticationManager();
}
}
src/main/java/com/agendaestudantil/configuracao/ResourceController.java
+18
View File
@@ -0,0 +1,18 @@
package com.agendaestudantil.configuracao;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
@Controller
public class ResourceController {
@GetMapping("/")
public String index() {
return "forward:/login.html";
}
@GetMapping("/app")
public String app() {
return "forward:/calendario.html";
}
}
src/main/java/com/agendaestudantil/controlador/DisciplinaControlador.java
+74
View File
@@ -0,0 +1,74 @@
package com.agendaestudantil.controlador;
import com.agendaestudantil.dto.RequisicaoDisciplinaDTO;
import com.agendaestudantil.dto.RespostaApi;
import com.agendaestudantil.dto.RespostaDisciplinaDTO;
import com.agendaestudantil.entidade.Disciplina;
import com.agendaestudantil.servico.DisciplinaServico;
import jakarta.validation.Valid;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/api/disciplinas")
public class DisciplinaControlador {
private final DisciplinaServico disciplinaServico;
public DisciplinaControlador(DisciplinaServico disciplinaServico) {
this.disciplinaServico = disciplinaServico;
}
@PostMapping
public ResponseEntity<RespostaApi<RespostaDisciplinaDTO>> criarDisciplina(
@Valid @RequestBody RequisicaoDisciplinaDTO dto) {
Disciplina disciplina = new Disciplina();
disciplina.setNome(dto.nome());
disciplina.setProfessor(dto.professor());
disciplina.setSala(dto.sala());
disciplina.setCor(dto.cor());
RespostaDisciplinaDTO resposta = disciplinaServico.criarDisciplina(disciplina, dto.estudanteId());
return ResponseEntity.status(HttpStatus.CREATED).body(RespostaApi.sucesso(resposta));
}
@GetMapping("/estudante/{estudanteId}")
public ResponseEntity<RespostaApi<List<RespostaDisciplinaDTO>>> listarPorEstudante(
@PathVariable String estudanteId) {
List<RespostaDisciplinaDTO> disciplinas = disciplinaServico.listarPorEstudante(estudanteId);
return ResponseEntity.ok(RespostaApi.sucesso(disciplinas));
}
@GetMapping("/{id}")
public ResponseEntity<RespostaApi<RespostaDisciplinaDTO>> buscarPorId(
@PathVariable String id,
@RequestParam String estudanteId) {
RespostaDisciplinaDTO disciplina = disciplinaServico.buscarPorId(id, estudanteId);
return ResponseEntity.ok(RespostaApi.sucesso(disciplina));
}
@PutMapping("/{id}")
public ResponseEntity<RespostaApi<RespostaDisciplinaDTO>> atualizarDisciplina(
@PathVariable String id,
@Valid @RequestBody RequisicaoDisciplinaDTO dto) {
Disciplina disciplina = new Disciplina();
disciplina.setNome(dto.nome());
disciplina.setProfessor(dto.professor());
disciplina.setSala(dto.sala());
disciplina.setCor(dto.cor());
RespostaDisciplinaDTO resposta = disciplinaServico.atualizarDisciplina(id, disciplina, dto.estudanteId());
return ResponseEntity.ok(RespostaApi.sucesso(resposta));
}
@DeleteMapping("/{id}")
public ResponseEntity<RespostaApi<Void>> excluirDisciplina(
@PathVariable String id,
@RequestParam String estudanteId) {
disciplinaServico.excluirDisciplina(id, estudanteId);
return ResponseEntity.status(HttpStatus.NO_CONTENT).body(RespostaApi.sucesso(null));
}
}
src/main/java/com/agendaestudantil/controlador/EstudanteControlador.java
+44
View File
@@ -0,0 +1,44 @@
package com.agendaestudantil.controlador;
import com.agendaestudantil.dto.RespostaApi;
import com.agendaestudantil.dto.RequisicaoCadastroDTO;
import com.agendaestudantil.dto.RespostaEstudanteDTO;
import com.agendaestudantil.dto.RequisicaoLoginDTO;
import com.agendaestudantil.dto.RespostaLoginDTO;
import com.agendaestudantil.servico.EstudanteServico;
import jakarta.validation.Valid;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/api/estudantes")
public class EstudanteControlador {
private final EstudanteServico estudanteServico;
public EstudanteControlador(EstudanteServico estudanteServico) {
this.estudanteServico = estudanteServico;
}
@PostMapping("/cadastro")
public ResponseEntity<RespostaApi<RespostaEstudanteDTO>> cadastrar(@Valid @RequestBody RequisicaoCadastroDTO dto) {
RespostaEstudanteDTO resposta = estudanteServico.cadastrar(dto);
return ResponseEntity.status(HttpStatus.CREATED).body(RespostaApi.sucesso(resposta));
}
@PostMapping("/login")
public ResponseEntity<RespostaApi<RespostaLoginDTO>> login(@Valid @RequestBody RequisicaoLoginDTO dto) {
RespostaLoginDTO resposta = estudanteServico.login(dto);
return ResponseEntity.ok(RespostaApi.sucesso(resposta));
}
// Retorna dados do usuário autenticado via JWT (sem precisar do ID na URL)
@GetMapping("/me")
public ResponseEntity<RespostaApi<RespostaEstudanteDTO>> me(@AuthenticationPrincipal UserDetails userDetails) {
RespostaEstudanteDTO resposta = estudanteServico.buscarPorId(userDetails.getUsername());
return ResponseEntity.ok(RespostaApi.sucesso(resposta));
}
}
src/main/java/com/agendaestudantil/controlador/EventoControlador.java
+96
View File
@@ -0,0 +1,96 @@
package com.agendaestudantil.controlador;
import com.agendaestudantil.dto.RequisicaoEventoDTO;
import com.agendaestudantil.dto.RespostaApi;
import com.agendaestudantil.dto.RespostaEventoDTO;
import com.agendaestudantil.entidade.Evento;
import com.agendaestudantil.servico.EventoServico;
import jakarta.validation.Valid;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.util.List;
@RestController
@RequestMapping("/api/eventos")
public class EventoControlador {
private final EventoServico eventoServico;
public EventoControlador(EventoServico eventoServico) {
this.eventoServico = eventoServico;
}
@PostMapping
public ResponseEntity<RespostaApi<RespostaEventoDTO>> criarEvento(
@Valid @RequestBody RequisicaoEventoDTO dto) {
Evento evento = new Evento();
evento.setTitulo(dto.titulo());
evento.setDescricao(dto.descricao());
evento.setTipo(dto.tipo());
evento.setLocal(dto.local());
evento.setDataHora(dto.dataHora());
evento.setDisciplinaId(dto.disciplinaId());
RespostaEventoDTO resposta = eventoServico.criarEvento(evento, dto.estudanteId());
return ResponseEntity.status(HttpStatus.CREATED).body(RespostaApi.sucesso(resposta));
}
@GetMapping("/estudante/{estudanteId}")
public ResponseEntity<RespostaApi<List<RespostaEventoDTO>>> listarPorEstudante(
@PathVariable String estudanteId) {
List<RespostaEventoDTO> eventos = eventoServico.listarPorEstudante(estudanteId);
return ResponseEntity.ok(RespostaApi.sucesso(eventos));
}
@GetMapping("/estudante/{estudanteId}/periodo")
public ResponseEntity<RespostaApi<List<RespostaEventoDTO>>> listarPorPeriodo(
@PathVariable String estudanteId,
@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime inicio,
@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime fim) {
List<RespostaEventoDTO> eventos = eventoServico.listarPorPeriodo(estudanteId, inicio, fim);
return ResponseEntity.ok(RespostaApi.sucesso(eventos));
}
@GetMapping("/estudante/{estudanteId}/proximos")
public ResponseEntity<RespostaApi<List<RespostaEventoDTO>>> listarProximosEventos(
@PathVariable String estudanteId) {
List<RespostaEventoDTO> eventos = eventoServico.listarProximosEventos(estudanteId);
return ResponseEntity.ok(RespostaApi.sucesso(eventos));
}
@GetMapping("/{id}")
public ResponseEntity<RespostaApi<RespostaEventoDTO>> buscarPorId(
@PathVariable String id,
@RequestParam String estudanteId) {
RespostaEventoDTO evento = eventoServico.buscarPorId(id, estudanteId);
return ResponseEntity.ok(RespostaApi.sucesso(evento));
}
@PutMapping("/{id}")
public ResponseEntity<RespostaApi<RespostaEventoDTO>> atualizarEvento(
@PathVariable String id,
@Valid @RequestBody RequisicaoEventoDTO dto) {
Evento evento = new Evento();
evento.setTitulo(dto.titulo());
evento.setDescricao(dto.descricao());
evento.setTipo(dto.tipo());
evento.setLocal(dto.local());
evento.setDataHora(dto.dataHora());
evento.setDisciplinaId(dto.disciplinaId());
RespostaEventoDTO resposta = eventoServico.atualizarEvento(id, evento, dto.estudanteId());
return ResponseEntity.ok(RespostaApi.sucesso(resposta));
}
@DeleteMapping("/{id}")
public ResponseEntity<RespostaApi<Void>> excluirEvento(
@PathVariable String id,
@RequestParam String estudanteId) {
eventoServico.excluirEvento(id, estudanteId);
return ResponseEntity.status(HttpStatus.NO_CONTENT).body(RespostaApi.sucesso(null));
}
}
src/main/java/com/agendaestudantil/controlador/TarefaControlador.java
+86
View File
@@ -0,0 +1,86 @@
package com.agendaestudantil.controlador;
import com.agendaestudantil.dto.RespostaApi;
import com.agendaestudantil.dto.RequisicaoTarefaDTO;
import com.agendaestudantil.dto.RespostaTarefaDTO;
import com.agendaestudantil.servico.TarefaServico;
import jakarta.validation.Valid;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDate;
import java.util.List;
@RestController
@RequestMapping("/api/tarefas")
public class TarefaControlador {
private final TarefaServico tarefaServico;
public TarefaControlador(TarefaServico tarefaServico) {
this.tarefaServico = tarefaServico;
}
@PostMapping
public ResponseEntity<RespostaApi<RespostaTarefaDTO>> criarTarefa(@Valid @RequestBody RequisicaoTarefaDTO dto) {
RespostaTarefaDTO tarefa = tarefaServico.criarTarefa(dto);
return ResponseEntity.status(HttpStatus.CREATED).body(RespostaApi.sucesso(tarefa));
}
@GetMapping("/estudante/{estudanteId}")
public ResponseEntity<RespostaApi<List<RespostaTarefaDTO>>> listarTarefasPorEstudante(
@PathVariable String estudanteId) {
List<RespostaTarefaDTO> tarefas = tarefaServico.listarTarefasPorEstudante(estudanteId);
return ResponseEntity.ok(RespostaApi.sucesso(tarefas));
}
@GetMapping("/estudante/{estudanteId}/pendentes")
public ResponseEntity<RespostaApi<List<RespostaTarefaDTO>>> listarTarefasPendentes(
@PathVariable String estudanteId) {
List<RespostaTarefaDTO> tarefas = tarefaServico.listarTarefasPendentes(estudanteId);
return ResponseEntity.ok(RespostaApi.sucesso(tarefas));
}
@GetMapping("/estudante/{estudanteId}/data")
public ResponseEntity<RespostaApi<List<RespostaTarefaDTO>>> listarTarefasPorData(
@PathVariable String estudanteId,
@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate data) {
List<RespostaTarefaDTO> tarefas = tarefaServico.listarTarefasPorData(estudanteId, data);
return ResponseEntity.ok(RespostaApi.sucesso(tarefas));
}
@GetMapping("/estudante/{estudanteId}/periodo")
public ResponseEntity<RespostaApi<List<RespostaTarefaDTO>>> listarTarefasPorPeriodo(
@PathVariable String estudanteId,
@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate inicio,
@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate fim) {
List<RespostaTarefaDTO> tarefas = tarefaServico.listarTarefasPorPeriodo(estudanteId, inicio, fim);
return ResponseEntity.ok(RespostaApi.sucesso(tarefas));
}
@GetMapping("/{id}")
public ResponseEntity<RespostaApi<RespostaTarefaDTO>> buscarTarefaPorId(@PathVariable String id) {
RespostaTarefaDTO dto = tarefaServico.buscarTarefaPorId(id);
return ResponseEntity.ok(RespostaApi.sucesso(dto));
}
@PutMapping("/{id}")
public ResponseEntity<RespostaApi<RespostaTarefaDTO>> atualizarTarefa(@PathVariable String id,
@Valid @RequestBody RequisicaoTarefaDTO dto) {
RespostaTarefaDTO tarefa = tarefaServico.atualizarTarefa(id, dto);
return ResponseEntity.ok(RespostaApi.sucesso(tarefa));
}
@DeleteMapping("/{id}")
public ResponseEntity<RespostaApi<Void>> excluirTarefa(@PathVariable String id) {
tarefaServico.excluirTarefa(id);
return ResponseEntity.status(HttpStatus.NO_CONTENT).body(RespostaApi.sucesso(null));
}
@PatchMapping("/{id}/concluir")
public ResponseEntity<RespostaApi<RespostaTarefaDTO>> marcarConcluida(@PathVariable String id) {
RespostaTarefaDTO tarefa = tarefaServico.marcarConcluida(id);
return ResponseEntity.ok(RespostaApi.sucesso(tarefa));
}
}
src/main/java/com/agendaestudantil/dto/RequisicaoCadastroDTO.java
+16
View File
@@ -0,0 +1,16 @@
package com.agendaestudantil.dto;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
public record RequisicaoCadastroDTO(
@NotBlank String nome,
@Email @NotBlank String email,
@NotBlank @Size(min = 6) String senha,
@NotBlank String curso,
@NotNull @Min(1) Integer periodo
) {
}
src/main/java/com/agendaestudantil/dto/RequisicaoDisciplinaDTO.java
+11
View File
@@ -0,0 +1,11 @@
package com.agendaestudantil.dto;
import jakarta.validation.constraints.NotBlank;
public record RequisicaoDisciplinaDTO(
@NotBlank String nome,
String professor,
String sala,
String cor,
@NotBlank String estudanteId
) {}
src/main/java/com/agendaestudantil/dto/RequisicaoEventoDTO.java
+17
View File
@@ -0,0 +1,17 @@
package com.agendaestudantil.dto;
import com.agendaestudantil.entidade.Evento;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import java.time.LocalDateTime;
public record RequisicaoEventoDTO(
@NotBlank String titulo,
String descricao,
@NotNull Evento.TipoEvento tipo,
String local,
String disciplinaId,
@NotNull LocalDateTime dataHora,
@NotBlank String estudanteId
) {}
src/main/java/com/agendaestudantil/dto/RequisicaoLoginDTO.java
+10
View File
@@ -0,0 +1,10 @@
package com.agendaestudantil.dto;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
public record RequisicaoLoginDTO(
@Email @NotBlank String email,
@NotBlank String senha
) {
}
src/main/java/com/agendaestudantil/dto/RequisicaoTarefaDTO.java
+19
View File
@@ -0,0 +1,19 @@
package com.agendaestudantil.dto;
import com.agendaestudantil.entidade.Tarefa;
import jakarta.validation.constraints.FutureOrPresent;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import java.time.LocalDate;
public record RequisicaoTarefaDTO(
@NotBlank String titulo,
String descricao,
@NotNull(message = "Prioridade é obrigatória") Tarefa.Prioridade prioridade,
Tarefa.StatusTarefa status,
@NotNull @FutureOrPresent LocalDate dataEntrega,
String disciplinaId,
@NotBlank(message = "ID do estudante é obrigatório") String estudanteId
) {
}
src/main/java/com/agendaestudantil/dto/RespostaApi.java
+9
View File
@@ -0,0 +1,9 @@
package com.agendaestudantil.dto;
import java.time.LocalDateTime;
public record RespostaApi<T>(T data, String message, LocalDateTime timestamp) {
public static <T> RespostaApi<T> sucesso(T data) {
return new RespostaApi<>(data, "Sucesso", LocalDateTime.now());
}
}
src/main/java/com/agendaestudantil/dto/RespostaDisciplinaDTO.java
+10
View File
@@ -0,0 +1,10 @@
package com.agendaestudantil.dto;
public record RespostaDisciplinaDTO(
String id,
String estudanteId,
String nome,
String professor,
String sala,
String cor
) {}
src/main/java/com/agendaestudantil/dto/RespostaEstudanteDTO.java
+10
View File
@@ -0,0 +1,10 @@
package com.agendaestudantil.dto;
public record RespostaEstudanteDTO(
String id,
String nome,
String email,
String curso,
Integer periodo
) {
}
src/main/java/com/agendaestudantil/dto/RespostaEventoDTO.java
+14
View File
@@ -0,0 +1,14 @@
package com.agendaestudantil.dto;
import java.time.LocalDateTime;
public record RespostaEventoDTO(
String id,
String estudanteId,
String titulo,
String descricao,
String tipo,
String local,
String disciplinaId,
LocalDateTime dataHora
) {}
src/main/java/com/agendaestudantil/dto/RespostaLoginDTO.java
+4
View File
@@ -0,0 +1,4 @@
package com.agendaestudantil.dto;
public record RespostaLoginDTO(String token, RespostaEstudanteDTO estudante) {
}
src/main/java/com/agendaestudantil/dto/RespostaTarefaDTO.java
+14
View File
@@ -0,0 +1,14 @@
package com.agendaestudantil.dto;
import java.time.LocalDate;
public record RespostaTarefaDTO(
String id,
String titulo,
String descricao,
String prioridade,
String status,
LocalDate dataEntrega,
String disciplinaId,
String estudanteId
) {}
src/main/java/com/agendaestudantil/entidade/Disciplina.java
+28
View File
@@ -0,0 +1,28 @@
package com.agendaestudantil.entidade;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.index.CompoundIndex;
import org.springframework.data.mongodb.core.mapping.Document;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = false)
@Document(collection = "disciplinas")
@CompoundIndex(name = "estudante_nome_idx", def = "{estudanteId: 1, nome: 1}")
public class Disciplina extends EntidadeAuditoria {
@Id
private String id;
private String estudanteId;
private String nome;
private String professor;
private String sala;
private String cor;
}
src/main/java/com/agendaestudantil/entidade/EntidadeAuditoria.java
+21
View File
@@ -0,0 +1,21 @@
package com.agendaestudantil.entidade;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import java.time.LocalDateTime;
@Data
@NoArgsConstructor
@AllArgsConstructor
public abstract class EntidadeAuditoria {
@CreatedDate
private LocalDateTime dataCriacao;
@LastModifiedDate
private LocalDateTime dataAtualizacao;
}
src/main/java/com/agendaestudantil/entidade/Estudante.java
+33
View File
@@ -0,0 +1,33 @@
package com.agendaestudantil.entidade;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.Document;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = false)
@Document(collection = "estudantes")
public class Estudante extends EntidadeAuditoria {
@Id
private String id;
@Indexed(unique = true)
private String email;
private String nome;
private String senha;
private String curso;
private Integer periodo;
}
src/main/java/com/agendaestudantil/entidade/Evento.java
+36
View File
@@ -0,0 +1,36 @@
package com.agendaestudantil.entidade;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.index.CompoundIndex;
import org.springframework.data.mongodb.core.mapping.Document;
import java.time.LocalDateTime;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = false)
@Document(collection = "eventos")
@CompoundIndex(name = "estudante_data_hora_idx", def = "{estudanteId: 1, dataHora: 1}")
public class Evento extends EntidadeAuditoria {
@Id
private String id;
private String estudanteId;
private String titulo;
private String descricao;
private TipoEvento tipo;
private String local;
private String disciplinaId;
private LocalDateTime dataHora;
public enum TipoEvento {
AULA, PROVA, TRABALHO, ESTUDO, EXAME, OUTRO
}
}
src/main/java/com/agendaestudantil/entidade/Tarefa.java
+44
View File
@@ -0,0 +1,44 @@
package com.agendaestudantil.entidade;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.index.CompoundIndex;
import org.springframework.data.mongodb.core.index.CompoundIndexes;
import org.springframework.data.mongodb.core.mapping.Document;
import java.time.LocalDate;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(callSuper = false)
@Document(collection = "tarefas")
@CompoundIndexes({
@CompoundIndex(name = "estudante_data_entrega_idx", def = "{estudanteId: 1, dataEntrega: 1}"),
@CompoundIndex(name = "estudante_status_idx", def = "{estudanteId: 1, status: 1}")
})
public class Tarefa extends EntidadeAuditoria {
@Id
private String id;
private String titulo;
private String descricao;
private Prioridade prioridade;
private StatusTarefa status;
private LocalDate dataEntrega;
private String disciplinaId;
private String estudanteId;
public enum Prioridade {
BAIXA, MEDIA, ALTA, URGENTE
}
public enum StatusTarefa {
PENDENTE, EM_ANDAMENTO, CONCLUIDA, ATRASADA
}
}
src/main/java/com/agendaestudantil/excecao/ExcecaoNegocio.java
+7
View File
@@ -0,0 +1,7 @@
package com.agendaestudantil.excecao;
public class ExcecaoNegocio extends RuntimeException {
public ExcecaoNegocio(String message) {
super(message);
}
}
src/main/java/com/agendaestudantil/excecao/ExcecaoRecursoNaoEncontrado.java
+7
View File
@@ -0,0 +1,7 @@
package com.agendaestudantil.excecao;
public class ExcecaoRecursoNaoEncontrado extends RuntimeException {
public ExcecaoRecursoNaoEncontrado(String message) {
super(message);
}
}
src/main/java/com/agendaestudantil/excecao/ManipuladorExcecaoGlobal.java
+53
View File
@@ -0,0 +1,53 @@
package com.agendaestudantil.excecao;
import com.agendaestudantil.dto.RespostaApi;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.server.ResponseStatusException;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;
@RestControllerAdvice
public class ManipuladorExcecaoGlobal {
@ExceptionHandler(ExcecaoRecursoNaoEncontrado.class)
public ResponseEntity<RespostaApi<Void>> handleResourceNotFound(ExcecaoRecursoNaoEncontrado ex) {
return ResponseEntity.status(HttpStatus.NOT_FOUND)
.body(new RespostaApi<>(null, ex.getMessage(), LocalDateTime.now()));
}
@ExceptionHandler(ExcecaoNegocio.class)
public ResponseEntity<RespostaApi<Void>> handleExcecaoNegocio(ExcecaoNegocio ex) {
return ResponseEntity.status(HttpStatus.BAD_REQUEST)
.body(new RespostaApi<>(null, ex.getMessage(), LocalDateTime.now()));
}
@ExceptionHandler(MethodArgumentNotValidException.class)
public ResponseEntity<RespostaApi<Map<String, String>>> handleValidationException(
MethodArgumentNotValidException ex) {
Map<String, String> errors = new HashMap<>();
for (FieldError error : ex.getBindingResult().getFieldErrors()) {
errors.put(error.getField(), error.getDefaultMessage());
}
return ResponseEntity.status(HttpStatus.BAD_REQUEST)
.body(new RespostaApi<>(errors, "Falha na validação", LocalDateTime.now()));
}
@ExceptionHandler(ResponseStatusException.class)
public ResponseEntity<RespostaApi<Void>> handleResponseStatusException(ResponseStatusException ex) {
return ResponseEntity.status(ex.getStatusCode())
.body(new RespostaApi<>(null, ex.getReason(), LocalDateTime.now()));
}
@ExceptionHandler(Exception.class)
public ResponseEntity<RespostaApi<Void>> handleGenericException(Exception ex) {
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body(new RespostaApi<>(null, "Erro interno no servidor: " + ex.getMessage(), LocalDateTime.now()));
}
}
src/main/java/com/agendaestudantil/filtro/FiltroJwt.java
+62
View File
@@ -0,0 +1,62 @@
package com.agendaestudantil.filtro;
import com.agendaestudantil.utilitario.UtilJwt;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
import java.io.IOException;
@Component
public class FiltroJwt extends OncePerRequestFilter {
private final UtilJwt utilJwt;
private final UserDetailsService userDetailsService;
public FiltroJwt(UtilJwt utilJwt, UserDetailsService userDetailsService) {
this.utilJwt = utilJwt;
this.userDetailsService = userDetailsService;
}
@Override
protected boolean shouldNotFilter(HttpServletRequest request) {
String path = request.getRequestURI();
return path.equals("/") || path.equals("/index.html") || path.equals("/favicon.ico")
|| path.startsWith("/static/") || path.startsWith("/css/") || path.startsWith("/js/")
|| path.startsWith("/img/") || path.endsWith(".css") || path.endsWith(".js")
|| path.endsWith(".ico") || path.endsWith(".html");
}
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
throws ServletException, IOException {
String header = request.getHeader("Authorization");
String token = null;
String estudanteId = null;
if (header != null && header.startsWith("Bearer ")) {
token = header.substring(7);
estudanteId = utilJwt.getEstudanteIdFromToken(token);
}
if (estudanteId != null && SecurityContextHolder.getContext().getAuthentication() == null) {
UserDetails userDetails = userDetailsService.loadUserByUsername(estudanteId);
if (utilJwt.validateToken(token)) {
UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
userDetails, null, userDetails.getAuthorities());
SecurityContextHolder.getContext().setAuthentication(authentication);
}
}
filterChain.doFilter(request, response);
}
}
src/main/java/com/agendaestudantil/repositorio/DisciplinaRepositorio.java
+11
View File
@@ -0,0 +1,11 @@
package com.agendaestudantil.repositorio;
import com.agendaestudantil.entidade.Disciplina;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface DisciplinaRepositorio extends MongoRepository<Disciplina, String> {
List<Disciplina> findByEstudanteId(String estudanteId);
}
src/main/java/com/agendaestudantil/repositorio/EstudanteRepositorio.java
+12
View File
@@ -0,0 +1,12 @@
package com.agendaestudantil.repositorio;
import com.agendaestudantil.entidade.Estudante;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;
import java.util.Optional;
@Repository
public interface EstudanteRepositorio extends MongoRepository<Estudante, String> {
Optional<Estudante> findByEmail(String email);
boolean existsByEmail(String email);
}
src/main/java/com/agendaestudantil/repositorio/EventoRepositorio.java
+22
View File
@@ -0,0 +1,22 @@
package com.agendaestudantil.repositorio;
import com.agendaestudantil.entidade.Evento;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.data.mongodb.repository.Query;
import org.springframework.stereotype.Repository;
import java.time.LocalDateTime;
import java.util.List;
@Repository
public interface EventoRepositorio extends MongoRepository<Evento, String> {
List<Evento> findByEstudanteId(String estudanteId);
List<Evento> findByDisciplinaId(String disciplinaId);
@Query("{'estudanteId': ?0, 'dataHora': {$gte: ?1, $lte: ?2}}")
List<Evento> findByEstudanteIdAndDataHoraBetween(String estudanteId, LocalDateTime inicio, LocalDateTime fim);
@Query("{'estudanteId': ?0, 'dataHora': {$gte: ?1}}")
List<Evento> findProximosEventosByEstudanteId(String estudanteId, LocalDateTime data);
}
src/main/java/com/agendaestudantil/repositorio/TarefaRepositorio.java
+27
View File
@@ -0,0 +1,27 @@
package com.agendaestudantil.repositorio;
import com.agendaestudantil.entidade.Tarefa;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.data.mongodb.repository.Query;
import org.springframework.stereotype.Repository;
import java.time.LocalDate;
import java.util.List;
@Repository
public interface TarefaRepositorio extends MongoRepository<Tarefa, String> {
List<Tarefa> findByEstudanteId(String estudanteId);
List<Tarefa> findByEstudanteIdAndStatus(String estudanteId, Tarefa.StatusTarefa status);
List<Tarefa> findByDisciplinaId(String disciplinaId);
@Query("{'estudanteId': ?0, 'dataEntrega': ?1}")
List<Tarefa> findByEstudanteIdAndDataEntrega(String estudanteId, LocalDate data);
@Query("{'estudanteId': ?0, 'dataEntrega': {$gte: ?1, $lte: ?2}}")
List<Tarefa> findByEstudanteIdAndDataEntregaBetween(String estudanteId, LocalDate inicio, LocalDate fim);
@Query("{'estudanteId': ?0, 'status': {$ne: ?1}}")
List<Tarefa> findTarefasPendentesByEstudanteId(String estudanteId, Tarefa.StatusTarefa status);
}
src/main/java/com/agendaestudantil/seguranca/DetalhesUsuarioPersonalizado.java
+53
View File
@@ -0,0 +1,53 @@
package com.agendaestudantil.seguranca;
import com.agendaestudantil.entidade.Estudante;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import java.util.Collection;
import java.util.Collections;
public class DetalhesUsuarioPersonalizado implements UserDetails {
private final Estudante estudante;
public DetalhesUsuarioPersonalizado(Estudante estudante) {
this.estudante = estudante;
}
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
return Collections.singleton(new SimpleGrantedAuthority("ROLE_USER"));
}
@Override
public String getPassword() {
return estudante.getSenha();
}
@Override
public String getUsername() {
return estudante.getId();
}
@Override
public boolean isAccountNonExpired() {
return true;
}
@Override
public boolean isAccountNonLocked() {
return true;
}
@Override
public boolean isCredentialsNonExpired() {
return true;
}
@Override
public boolean isEnabled() {
return true;
}
}
src/main/java/com/agendaestudantil/seguranca/ServicoAutenticacaoUsuario.java
+26
View File
@@ -0,0 +1,26 @@
package com.agendaestudantil.seguranca;
import com.agendaestudantil.entidade.Estudante;
import com.agendaestudantil.repositorio.EstudanteRepositorio;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
@Service
public class ServicoAutenticacaoUsuario implements UserDetailsService {
private final EstudanteRepositorio estudanteRepositorio;
public ServicoAutenticacaoUsuario(EstudanteRepositorio estudanteRepositorio) {
this.estudanteRepositorio = estudanteRepositorio;
}
@Override
public UserDetails loadUserByUsername(String estudanteId) throws UsernameNotFoundException {
Estudante estudante = estudanteRepositorio.findById(estudanteId)
.orElseThrow(() -> new UsernameNotFoundException("Estudante não encontrado"));
return new DetalhesUsuarioPersonalizado(estudante);
}
}
src/main/java/com/agendaestudantil/servico/DisciplinaServico.java
+92
View File
@@ -0,0 +1,92 @@
package com.agendaestudantil.servico;
import com.agendaestudantil.dto.RespostaDisciplinaDTO;
import com.agendaestudantil.entidade.Disciplina;
import com.agendaestudantil.excecao.ExcecaoRecursoNaoEncontrado;
import com.agendaestudantil.repositorio.DisciplinaRepositorio;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;
import org.springframework.web.server.ResponseStatusException;
import java.util.List;
@Service
public class DisciplinaServico {
private static final Logger log = LoggerFactory.getLogger(DisciplinaServico.class);
private final DisciplinaRepositorio disciplinaRepositorio;
public DisciplinaServico(DisciplinaRepositorio disciplinaRepositorio) {
this.disciplinaRepositorio = disciplinaRepositorio;
}
private void validarAcesso(String estudanteId) {
String authUser = SecurityContextHolder.getContext().getAuthentication().getName();
if (!authUser.equals(estudanteId)) {
log.error("Acesso negado. Usuário {} tentou acessar recurso do estudante {}", authUser, estudanteId);
throw new ResponseStatusException(HttpStatus.FORBIDDEN, "Acesso negado");
}
}
public RespostaDisciplinaDTO criarDisciplina(Disciplina disciplina, String estudanteId) {
log.debug("Criando disciplina para estudante: {}", estudanteId);
validarAcesso(estudanteId);
disciplina.setEstudanteId(estudanteId);
Disciplina salva = disciplinaRepositorio.save(disciplina);
return toDTO(salva);
}
public List<RespostaDisciplinaDTO> listarPorEstudante(String estudanteId) {
log.debug("Listando disciplinas para estudante: {}", estudanteId);
validarAcesso(estudanteId);
return disciplinaRepositorio.findByEstudanteId(estudanteId).stream()
.map(this::toDTO)
.toList();
}
public RespostaDisciplinaDTO buscarPorId(String id, String estudanteId) {
Disciplina disciplina = getDisciplinaEntity(id);
validarAcesso(disciplina.getEstudanteId());
return toDTO(disciplina);
}
public RespostaDisciplinaDTO atualizarDisciplina(String id, Disciplina disciplinaAtualizada, String estudanteId) {
Disciplina disciplina = getDisciplinaEntity(id);
validarAcesso(disciplina.getEstudanteId());
disciplina.setNome(disciplinaAtualizada.getNome());
disciplina.setProfessor(disciplinaAtualizada.getProfessor());
disciplina.setSala(disciplinaAtualizada.getSala());
disciplina.setCor(disciplinaAtualizada.getCor());
return toDTO(disciplinaRepositorio.save(disciplina));
}
public void excluirDisciplina(String id, String estudanteId) {
Disciplina disciplina = getDisciplinaEntity(id);
validarAcesso(disciplina.getEstudanteId());
disciplinaRepositorio.delete(disciplina);
}
private Disciplina getDisciplinaEntity(String id) {
return disciplinaRepositorio.findById(id)
.orElseThrow(() -> new ExcecaoRecursoNaoEncontrado("Disciplina não encontrada"));
}
private RespostaDisciplinaDTO toDTO(Disciplina disciplina) {
return new RespostaDisciplinaDTO(
disciplina.getId(),
disciplina.getEstudanteId(),
disciplina.getNome(),
disciplina.getProfessor(),
disciplina.getSala(),
disciplina.getCor()
);
}
}
src/main/java/com/agendaestudantil/servico/EstudanteServico.java
+90
View File
@@ -0,0 +1,90 @@
package com.agendaestudantil.servico;
import com.agendaestudantil.dto.RequisicaoCadastroDTO;
import com.agendaestudantil.dto.RespostaEstudanteDTO;
import com.agendaestudantil.dto.RequisicaoLoginDTO;
import com.agendaestudantil.dto.RespostaLoginDTO;
import com.agendaestudantil.entidade.Estudante;
import com.agendaestudantil.excecao.ExcecaoNegocio;
import com.agendaestudantil.excecao.ExcecaoRecursoNaoEncontrado;
import com.agendaestudantil.repositorio.EstudanteRepositorio;
import com.agendaestudantil.utilitario.UtilJwt;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.web.server.ResponseStatusException;
import java.util.Optional;
@Service
public class EstudanteServico {
private static final Logger log = LoggerFactory.getLogger(EstudanteServico.class);
private final EstudanteRepositorio estudanteRepositorio;
private final PasswordEncoder passwordEncoder;
private final UtilJwt utilJwt;
public EstudanteServico(EstudanteRepositorio estudanteRepositorio, PasswordEncoder passwordEncoder,
UtilJwt utilJwt) {
this.estudanteRepositorio = estudanteRepositorio;
this.passwordEncoder = passwordEncoder;
this.utilJwt = utilJwt;
}
public RespostaEstudanteDTO cadastrar(RequisicaoCadastroDTO dto) {
log.debug("Acessando método cadastrar para email: {}", dto.email());
Optional<Estudante> existente = estudanteRepositorio.findByEmail(dto.email());
if (existente.isPresent()) {
log.error("Email já cadastrado: {}", dto.email());
throw new ExcecaoNegocio("Email já cadastrado");
}
Estudante estudante = new Estudante();
estudante.setNome(dto.nome());
estudante.setEmail(dto.email());
estudante.setSenha(passwordEncoder.encode(dto.senha()));
estudante.setCurso(dto.curso());
estudante.setPeriodo(dto.periodo());
Estudante salvo = estudanteRepositorio.save(estudante);
return toResponse(salvo);
}
public RespostaLoginDTO login(RequisicaoLoginDTO dto) {
log.debug("Acessando método login para email: {}", dto.email());
Optional<Estudante> estudanteParam = estudanteRepositorio.findByEmail(dto.email());
if (estudanteParam.isEmpty()) {
log.error("Email ou senha incorretos para email: {}", dto.email());
throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "Email ou senha incorretos");
}
Estudante estudante = estudanteParam.get();
if (!passwordEncoder.matches(dto.senha(), estudante.getSenha())) {
log.error("Falha ao validar senha para email: {}", dto.email());
throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "Email ou senha incorretos");
}
String token = utilJwt.generateToken(estudante.getId());
return new RespostaLoginDTO(token, toResponse(estudante));
}
public RespostaEstudanteDTO buscarPorId(String id) {
Estudante estudante = estudanteRepositorio.findById(id)
.orElseThrow(() -> new ExcecaoRecursoNaoEncontrado("Estudante não encontrado"));
return toResponse(estudante);
}
private RespostaEstudanteDTO toResponse(Estudante estudante) {
return new RespostaEstudanteDTO(
estudante.getId(),
estudante.getNome(),
estudante.getEmail(),
estudante.getCurso(),
estudante.getPeriodo());
}
}
src/main/java/com/agendaestudantil/servico/EventoServico.java
+111
View File
@@ -0,0 +1,111 @@
package com.agendaestudantil.servico;
import com.agendaestudantil.dto.RespostaEventoDTO;
import com.agendaestudantil.entidade.Evento;
import com.agendaestudantil.excecao.ExcecaoRecursoNaoEncontrado;
import com.agendaestudantil.repositorio.EventoRepositorio;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;
import org.springframework.web.server.ResponseStatusException;
import java.time.LocalDateTime;
import java.util.List;
@Service
public class EventoServico {
private static final Logger log = LoggerFactory.getLogger(EventoServico.class);
private final EventoRepositorio eventoRepositorio;
public EventoServico(EventoRepositorio eventoRepositorio) {
this.eventoRepositorio = eventoRepositorio;
}
private void validarAcesso(String estudanteId) {
String authUser = SecurityContextHolder.getContext().getAuthentication().getName();
if (!authUser.equals(estudanteId)) {
log.error("Acesso negado. Usuário {} tentou acessar recurso do estudante {}", authUser, estudanteId);
throw new ResponseStatusException(HttpStatus.FORBIDDEN, "Acesso negado");
}
}
public RespostaEventoDTO criarEvento(Evento evento, String estudanteId) {
log.debug("Criando evento para estudante: {}", estudanteId);
validarAcesso(estudanteId);
evento.setEstudanteId(estudanteId);
Evento salvo = eventoRepositorio.save(evento);
return toDTO(salvo);
}
public List<RespostaEventoDTO> listarPorEstudante(String estudanteId) {
log.debug("Listando eventos para estudante: {}", estudanteId);
validarAcesso(estudanteId);
return eventoRepositorio.findByEstudanteId(estudanteId).stream()
.map(this::toDTO)
.toList();
}
public List<RespostaEventoDTO> listarPorPeriodo(String estudanteId, LocalDateTime inicio, LocalDateTime fim) {
validarAcesso(estudanteId);
return eventoRepositorio.findByEstudanteIdAndDataHoraBetween(estudanteId, inicio, fim).stream()
.map(this::toDTO)
.toList();
}
public List<RespostaEventoDTO> listarProximosEventos(String estudanteId) {
validarAcesso(estudanteId);
return eventoRepositorio.findProximosEventosByEstudanteId(estudanteId, LocalDateTime.now()).stream()
.map(this::toDTO)
.toList();
}
public RespostaEventoDTO buscarPorId(String id, String estudanteId) {
Evento evento = getEventoEntity(id);
validarAcesso(evento.getEstudanteId());
return toDTO(evento);
}
public RespostaEventoDTO atualizarEvento(String id, Evento eventoAtualizado, String estudanteId) {
Evento evento = getEventoEntity(id);
validarAcesso(evento.getEstudanteId());
evento.setTitulo(eventoAtualizado.getTitulo());
evento.setDescricao(eventoAtualizado.getDescricao());
evento.setTipo(eventoAtualizado.getTipo());
evento.setLocal(eventoAtualizado.getLocal());
evento.setDataHora(eventoAtualizado.getDataHora());
evento.setDisciplinaId(eventoAtualizado.getDisciplinaId());
return toDTO(eventoRepositorio.save(evento));
}
public void excluirEvento(String id, String estudanteId) {
Evento evento = getEventoEntity(id);
validarAcesso(evento.getEstudanteId());
eventoRepositorio.delete(evento);
}
private Evento getEventoEntity(String id) {
return eventoRepositorio.findById(id)
.orElseThrow(() -> new ExcecaoRecursoNaoEncontrado("Evento não encontrado"));
}
private RespostaEventoDTO toDTO(Evento evento) {
return new RespostaEventoDTO(
evento.getId(),
evento.getEstudanteId(),
evento.getTitulo(),
evento.getDescricao(),
evento.getTipo() != null ? evento.getTipo().name() : null,
evento.getLocal(),
evento.getDisciplinaId(),
evento.getDataHora()
);
}
}
src/main/java/com/agendaestudantil/servico/TarefaServico.java
+139
View File
@@ -0,0 +1,139 @@
package com.agendaestudantil.servico;
import com.agendaestudantil.dto.RequisicaoTarefaDTO;
import com.agendaestudantil.dto.RespostaTarefaDTO;
import com.agendaestudantil.entidade.Tarefa;
import com.agendaestudantil.excecao.ExcecaoRecursoNaoEncontrado;
import com.agendaestudantil.repositorio.TarefaRepositorio;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;
import org.springframework.web.server.ResponseStatusException;
import java.time.LocalDate;
import java.util.List;
@Service
public class TarefaServico {
private static final Logger log = LoggerFactory.getLogger(TarefaServico.class);
private final TarefaRepositorio tarefaRepositorio;
public TarefaServico(TarefaRepositorio tarefaRepositorio) {
this.tarefaRepositorio = tarefaRepositorio;
}
private void validarAcesso(String estudanteId) {
String authUser = SecurityContextHolder.getContext().getAuthentication().getName();
if (!authUser.equals(estudanteId)) {
log.error("Acesso negado. Usuário {} tentou acessar recurso do estudante {}", authUser, estudanteId);
throw new ResponseStatusException(HttpStatus.FORBIDDEN, "Acesso negado");
}
}
private void validarAcessoTarefa(Tarefa tarefa) {
validarAcesso(tarefa.getEstudanteId());
}
public RespostaTarefaDTO criarTarefa(RequisicaoTarefaDTO dto) {
log.debug("Criando tarefa para estudante: {}", dto.estudanteId());
validarAcesso(dto.estudanteId());
Tarefa tarefa = new Tarefa();
tarefa.setTitulo(dto.titulo());
tarefa.setDescricao(dto.descricao());
tarefa.setPrioridade(dto.prioridade() != null ? dto.prioridade() : Tarefa.Prioridade.MEDIA);
tarefa.setStatus(dto.status() != null ? dto.status() : Tarefa.StatusTarefa.PENDENTE);
tarefa.setDataEntrega(dto.dataEntrega());
tarefa.setEstudanteId(dto.estudanteId());
if (dto.disciplinaId() != null) {
tarefa.setDisciplinaId(dto.disciplinaId());
}
return toDTO(tarefaRepositorio.save(tarefa));
}
public List<RespostaTarefaDTO> listarTarefasPorEstudante(String estudanteId) {
log.debug("Listando tarefas para estudante: {}", estudanteId);
validarAcesso(estudanteId);
return tarefaRepositorio.findByEstudanteId(estudanteId).stream()
.map(this::toDTO)
.toList();
}
public List<RespostaTarefaDTO> listarTarefasPendentes(String estudanteId) {
log.debug("Listando tarefas pendentes para estudante: {}", estudanteId);
validarAcesso(estudanteId);
return tarefaRepositorio.findTarefasPendentesByEstudanteId(estudanteId, Tarefa.StatusTarefa.CONCLUIDA).stream()
.map(this::toDTO)
.toList();
}
public List<RespostaTarefaDTO> listarTarefasPorData(String estudanteId, LocalDate data) {
validarAcesso(estudanteId);
return tarefaRepositorio.findByEstudanteIdAndDataEntrega(estudanteId, data).stream()
.map(this::toDTO)
.toList();
}
public List<RespostaTarefaDTO> listarTarefasPorPeriodo(String estudanteId, LocalDate inicio, LocalDate fim) {
validarAcesso(estudanteId);
return tarefaRepositorio.findByEstudanteIdAndDataEntregaBetween(estudanteId, inicio, fim).stream()
.map(this::toDTO)
.toList();
}
public RespostaTarefaDTO buscarTarefaPorId(String id) {
return toDTO(getTarefaEntity(id));
}
public RespostaTarefaDTO atualizarTarefa(String id, RequisicaoTarefaDTO dto) {
Tarefa tarefa = getTarefaEntity(id);
validarAcesso(tarefa.getEstudanteId());
tarefa.setTitulo(dto.titulo());
tarefa.setDescricao(dto.descricao());
tarefa.setPrioridade(dto.prioridade() != null ? dto.prioridade() : tarefa.getPrioridade());
tarefa.setStatus(dto.status() != null ? dto.status() : tarefa.getStatus());
tarefa.setDataEntrega(dto.dataEntrega());
if (dto.disciplinaId() != null) {
tarefa.setDisciplinaId(dto.disciplinaId());
}
return toDTO(tarefaRepositorio.save(tarefa));
}
public void excluirTarefa(String id) {
tarefaRepositorio.delete(getTarefaEntity(id));
}
public RespostaTarefaDTO marcarConcluida(String id) {
Tarefa tarefa = getTarefaEntity(id);
tarefa.setStatus(Tarefa.StatusTarefa.CONCLUIDA);
return toDTO(tarefaRepositorio.save(tarefa));
}
private Tarefa getTarefaEntity(String id) {
Tarefa tarefa = tarefaRepositorio.findById(id)
.orElseThrow(() -> new ExcecaoRecursoNaoEncontrado("Tarefa não encontrada"));
validarAcessoTarefa(tarefa);
return tarefa;
}
private RespostaTarefaDTO toDTO(Tarefa tarefa) {
return new RespostaTarefaDTO(
tarefa.getId(),
tarefa.getTitulo(),
tarefa.getDescricao(),
tarefa.getPrioridade() != null ? tarefa.getPrioridade().name() : null,
tarefa.getStatus() != null ? tarefa.getStatus().name() : null,
tarefa.getDataEntrega(),
tarefa.getDisciplinaId(),
tarefa.getEstudanteId());
}
}
src/main/java/com/agendaestudantil/utilitario/UtilJwt.java
+56
View File
@@ -0,0 +1,56 @@
package com.agendaestudantil.utilitario;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.security.Keys;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.crypto.SecretKey;
import java.nio.charset.StandardCharsets;
import java.util.Date;
@Component
public class UtilJwt {
private final String secret;
public UtilJwt(@Value("${jwt.secret}") String secret) {
this.secret = secret;
}
private SecretKey getSigningKey() {
return Keys.hmacShaKeyFor(secret.getBytes(StandardCharsets.UTF_8));
}
public String generateToken(String estudanteId) {
Date now = new Date();
Date expiryDate = new Date(now.getTime() + 24 * 60 * 60 * 1000L);
return Jwts.builder()
.subject(estudanteId)
.issuedAt(now)
.expiration(expiryDate)
.signWith(getSigningKey())
.compact();
}
public String getEstudanteIdFromToken(String token) {
Claims claims = Jwts.parser()
.verifyWith(getSigningKey())
.build()
.parseSignedClaims(token)
.getPayload();
return claims.getSubject();
}
public boolean validateToken(String token) {
try {
Jwts.parser().verifyWith(getSigningKey()).build().parseSignedClaims(token);
return true;
} catch (Exception e) {
return false;
}
}
}