A gestão de informações em ambientes educacionais e de carreira tem passado por uma transformação significativa, migrando de métodos tradicionais para plataformas digitais robustas. A era da internet revolucionou a forma como as instituições de ensino superior gerenciam os processos de empregabilidade dos seus graduados. Sistemas legados, frequentemente lentos, inseguros e com baixa capacidade operacioanl, são substituídos por soluções modernas que otimizam a eficiência e a precisão.
A implementação de um sistema integrado de recrutamento e emprego universitário, utilizando tecnologias avançadas como o framework Spring Boot para o backend e o sistema de gerenciamento de banco de dados MySQL para persistência, permite abordar deficiências históricas. Essa combinação tecnológica assegura maior agilidade na entrada e consulta de dados, melhoria na segurança das informações e facilita análises de desempenho e tendências. A precisão dos dados é maximizada, tornando a gestão de carreira mais científica e conveniente para estudantes, orientadores e empresas.
Este sistema é projetado para oferecer um conjunto abrangente de funcionalidades que apoiam a jornada de empregabilidade dos universitários. Entre as capacidades implementadas, destacam-se:
- Registro e acompanhamento de destinos de graduados.
- Módulo de consultoria de emprego e suporte aos estudantes.
- Tabelas de dicionário para padronização de dados.
- Gestão de orientadores e seus respectivos perfis.
- Publicação e gestão de anúncios de recrutamento e vagas de emprego.
- Upload e gerenciamento de currículos.
- Base de conhecimento sobre empregabilidade, incluindo artigos e dicas.
- Funcionalidades de coleção e comentários em materiais de conhecimento sobre emprego.
- Registro e perfis de empresas parceiras.
- Gestão de contas de usuários (estudantes, empresas, administradores).
- Capacidades de favoritar vagas e deixar comentários sobre elas.
- Sistema para submissão e acompanhamento de candidaturas de currículos.
- Painel de administração para supervisão e controle do sistema.
- Gestão de banners rotativos (carrossel) para destaque de informações.
A escolha do MySQL como banco de dados relacional primário garante o armazenamento seguro e confiável dos dados, com suporte a backups eficazes e integridade da informação. O sistema não só atende a todos os requisitos funcionais, mas também eleva os padrões de operabilidade e segurança, transformando o conceito de gestão de empregabilidade universitária em uma realidade prática e eficiente.
A seguir, são apresentados exemplos de implementação de controladores REST em Spring Boot, demonstrando a interação com o banco de dados para gerenciar entidades centrais do sistema.
Controller de Anúncios de Vagas
Este controlador gerencia as operações relacionadas aos anúncios de vagas de emprego, incluindo listagem, detalhes, criação, atualização e exclusão, além de funcionalidades de pesquisa e estatísticas.
package com.sistemaemprego.controle;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.sistemaemprego.entidade.AnuncioVaga;
import com.sistemaemprego.servico.AnuncioVagaServico;
import com.sistemaemprego.servico.FavoritoServico;
import com.sistemaemprego.entidade.Favorito;
import com.sistemaemprego.util.PageUtil;
import com.sistemaemprego.util.ResponseUtil;
import com.sistemaemprego.util.QueryWrapperUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.*;
import java.text.SimpleDateFormat;
/**
* Anúncios de Vagas
* Endpoint REST para gestão de anúncios de vagas.
*/
@RestController
@RequestMapping("/anunciosVaga")
public class AnuncioVagaController {
@Autowired
private AnuncioVagaServico anuncioVagaServico;
@Autowired
private FavoritoServico favoritoServico;
/**
* Listagem paginada para o backend
*/
@GetMapping("/paginacao")
public ResponseUtil listarPaginadoBackend(@RequestParam Map<String, Object> params, AnuncioVaga anuncioVaga) {
QueryWrapper<AnuncioVaga> queryWrapper = new QueryWrapper<>();
// Constrói a query com filtros e ordenação
PageUtil<AnuncioVaga> page = anuncioVagaServico.consultarPagina(params,
QueryWrapperUtil.ordenar(QueryWrapperUtil.entre(QueryWrapperUtil.likeOuIgual(queryWrapper, anuncioVaga), params), params));
return ResponseUtil.ok().put("dados", page);
}
/**
* Listagem paginada para o frontend (acesso público)
*/
@GetMapping("/publica")
public ResponseUtil listarPaginadoPublico(@RequestParam Map<String, Object> params, AnuncioVaga anuncioVaga) {
QueryWrapper<AnuncioVaga> queryWrapper = new QueryWrapper<>();
// Constrói a query com filtros e ordenação
PageUtil<AnuncioVaga> page = anuncioVagaServico.consultarPagina(params,
QueryWrapperUtil.ordenar(QueryWrapperUtil.entre(QueryWrapperUtil.likeOuIgual(queryWrapper, anuncioVaga), params), params));
return ResponseUtil.ok().put("dados", page);
}
/**
* Retorna todos os anúncios (sem paginação)
*/
@GetMapping("/todos")
public ResponseUtil listarTodos(AnuncioVaga anuncioVaga) {
QueryWrapper<AnuncioVaga> queryWrapper = new QueryWrapper<>();
queryWrapper.allEq(QueryWrapperUtil.allEQMapPre(anuncioVaga, "anunciosVaga"));
return ResponseUtil.ok().put("dados", anuncioVagaServico.selecionarListaView(queryWrapper));
}
/**
* Consulta detalhes de um anúncio
*/
@GetMapping("/consultar")
public ResponseUtil consultar(@RequestParam AnuncioVaga anuncioVaga) {
QueryWrapper<AnuncioVaga> queryWrapper = new QueryWrapper<>();
queryWrapper.allEq(QueryWrapperUtil.allEQMapPre(anuncioVaga, "anunciosVaga"));
AnuncioVaga view = anuncioVagaServico.selecionarView(queryWrapper);
return ResponseUtil.ok("Consulta de anúncio realizada com sucesso").put("dados", view);
}
/**
* Detalhes de um anúncio (backend)
*/
@GetMapping("/detalheAdministrativo/{id}")
public ResponseUtil detalheAdmin(@PathVariable("id") Long id) {
AnuncioVaga anuncioVaga = anuncioVagaServico.selecionarPorId(id);
if (anuncioVaga != null) {
anuncioVaga.setDataUltimaVisualizacao(new Date());
anuncioVagaServico.atualizarPorId(anuncioVaga); // Atualiza o timestamp de visualização
}
return ResponseUtil.ok().put("dados", anuncioVaga);
}
/**
* Detalhes de um anúncio (frontend, acesso público)
*/
@GetMapping("/detalhePublico/{id}")
public ResponseUtil detalhePublico(@PathVariable("id") Long id) {
AnuncioVaga anuncioVaga = anuncioVagaServico.selecionarPorId(id);
if (anuncioVaga != null) {
anuncioVaga.setDataUltimaVisualizacao(new Date());
anuncioVagaServico.atualizarPorId(anuncioVaga); // Atualiza o timestamp de visualização
}
return ResponseUtil.ok().put("dados", anuncioVaga);
}
/**
* Cria um novo anúncio (backend)
*/
@PostMapping("/criar")
public ResponseUtil criarAnuncio(@RequestBody AnuncioVaga anuncioVaga, HttpServletRequest request) {
// Gera um ID baseado no timestamp
anuncioVaga.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// ValidatorUtils.validarEntidade(anuncioVaga); // Validação de entidade, se implementado
anuncioVagaServico.inserir(anuncioVaga);
return ResponseUtil.ok();
}
/**
* Adiciona um novo anúncio (frontend)
*/
@PostMapping("/adicionar")
public ResponseUtil adicionarAnuncio(@RequestBody AnuncioVaga anuncioVaga, HttpServletRequest request) {
// Gera um ID baseado no timestamp
anuncioVaga.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// ValidatorUtils.validarEntidade(anuncioVaga); // Validação de entidade, se implementado
anuncioVagaServico.inserir(anuncioVaga);
return ResponseUtil.ok();
}
/**
* Atualiza um anúncio existente
*/
@PutMapping("/atualizar")
@Transactional
public ResponseUtil atualizarAnuncio(@RequestBody AnuncioVaga anuncioVaga, HttpServletRequest request) {
// ValidatorUtils.validarEntidade(anuncioVaga); // Validação de entidade
anuncioVagaServico.atualizarPorId(anuncioVaga); // Atualização completa
return ResponseUtil.ok();
}
/**
* Exclui um ou mais anúncios
*/
@DeleteMapping("/excluir")
public ResponseUtil excluirAnuncios(@RequestBody Long[] ids) {
anuncioVagaServico.excluirPorIds(Arrays.asList(ids));
return ResponseUtil.ok();
}
/**
* Endpoint de lembrete/notificação
*/
@GetMapping("/lembrete/{coluna}/{tipo}")
public ResponseUtil lembreteContagem(@PathVariable("coluna") String coluna, HttpServletRequest request,
@PathVariable("tipo") String tipo, @RequestParam Map<String, Object> map) {
map.put("coluna", coluna);
map.put("tipo", tipo);
if (tipo.equals("2")) { // Exemplo de tipo para período
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Calendar c = Calendar.getInstance();
Date dataInicioLembrete = null;
Date dataFimLembrete = null;
if (map.get("inicioLembrete") != null) {
Integer inicioLembrete = Integer.parseInt(map.get("inicioLembrete").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, inicioLembrete);
dataInicioLembrete = c.getTime();
map.put("inicioLembrete", sdf.format(dataInicioLembrete));
}
if (map.get("fimLembrete") != null) {
Integer fimLembrete = Integer.parseInt(map.get("fimLembrete").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH, fimLembrete);
dataFimLembrete = c.getTime();
map.put("fimLembrete", sdf.format(dataFimLembrete));
}
}
QueryWrapper<AnuncioVaga> queryWrapper = new QueryWrapper<>();
if (map.get("inicioLembrete") != null) {
queryWrapper.ge(coluna, map.get("inicioLembrete"));
}
if (map.get("fimLembrete") != null) {
queryWrapper.le(coluna, map.get("fimLembrete"));
}
int count = anuncioVagaServico.contar(queryWrapper);
return ResponseUtil.ok().put("contagem", count);
}
/**
* Ordenação inteligente para o frontend (por visualizações)
*/
@GetMapping("/ordenacaoAutomatica")
public ResponseUtil ordenarAutomaticamente(@RequestParam Map<String, Object> params, AnuncioVaga anuncioVaga, HttpServletRequest request) {
QueryWrapper<AnuncioVaga> queryWrapper = new QueryWrapper<>();
// Os parâmetros 'sort' e 'order' serão tratados pelo MPUtil.sort
params.put("sort", "dataUltimaVisualizacao"); // Campo de ordenação padrão
params.put("order", "desc"); // Ordem decrescente
PageUtil<AnuncioVaga> page = anuncioVagaServico.consultarPagina(params,
QueryWrapperUtil.ordenar(QueryWrapperUtil.entre(QueryWrapperUtil.likeOuIgual(queryWrapper, anuncioVaga), params), params));
return ResponseUtil.ok().put("dados", page);
}
/**
* Algoritmo de recomendação colaborativa (por categorias de vagas favoritas)
*/
@GetMapping("/ordenacaoColaborativa")
public ResponseUtil ordenarColaborativamente(@RequestParam Map<String, Object> params, AnuncioVaga anuncioVaga, HttpServletRequest request) {
String idUsuario = request.getSession().getAttribute("idUsuario").toString();
String colunaTipoInteligente = "categoriaVaga"; // Coluna para a recomendação
List<Favorito> favoritos = favoritoServico.listar(new QueryWrapper<Favorito>()
.eq("tipo", 1) // Tipo 1 para favorito de anúncio de vaga
.eq("idUsuario", idUsuario)
.eq("tabelaReferencia", "anunciosVaga")
.orderByDesc("dataAdicao"));
List<String> tiposInteligentes = new ArrayList<>();
Integer limite = params.get("limite") == null ? 10 : Integer.parseInt(params.get("limite").toString());
List<AnuncioVaga> anunciosRecomendados = new ArrayList<>();
// Adiciona anúncios baseados nas categorias favoritas do usuário
if (favoritos != null && !favoritos.isEmpty()) {
for (Favorito f : favoritos) {
anunciosRecomendados.addAll(anuncioVagaServico.listar(new QueryWrapper<AnuncioVaga>().eq(colunaTipoInteligente, f.getTipoInteligente())));
}
}
// Adiciona anúncios populares para preencher o limite, se necessário
QueryWrapper<AnuncioVaga> ewPopular = new QueryWrapper<>();
params.put("sort", "id"); // Ou 'visualizacoes' para mais relevância
params.put("order", "desc");
PageUtil<AnuncioVaga> paginaPopular = anuncioVagaServico.consultarPagina(params,
QueryWrapperUtil.ordenar(QueryWrapperUtil.entre(QueryWrapperUtil.likeOuIgual(ewPopular, anuncioVaga), params), params));
List<AnuncioVaga> listaPopular = (List<AnuncioVaga>) paginaPopular.getList();
if (anunciosRecomendados.size() < limite) {
int numParaAdicionar = Math.min((limite - anunciosRecomendados.size()), listaPopular.size());
for (AnuncioVaga a1 : listaPopular) {
boolean adicionarFlag = true;
for (AnuncioVaga a2 : anunciosRecomendados) {
if (a1.getId().equals(a2.getId())) { // Evita duplicatas
adicionarFlag = false;
break;
}
}
if (adicionarFlag) {
anunciosRecomendados.add(a1);
if (--numParaAdicionar == 0) break;
}
}
} else if (anunciosRecomendados.size() > limite) {
anunciosRecomendados = anunciosRecomendados.subList(0, limite);
}
paginaPopular.setList(anunciosRecomendados);
return ResponseUtil.ok().put("dados", paginaPopular);
}
/**
* Estatísticas por valor
*/
@GetMapping("/estatisticasValor/{eixoX}/{eixoY}")
public ResponseUtil estatisticasValor(@PathVariable("eixoY") String eixoY, @PathVariable("eixoX") String eixoX, HttpServletRequest request) {
Map<String, Object> params = new HashMap<>();
params.put("colunaX", eixoX);
params.put("colunaY", eixoY);
QueryWrapper<AnuncioVaga> queryWrapper = new QueryWrapper<>();
List<Map<String, Object>> resultado = anuncioVagaServico.selecionarValor(params, queryWrapper);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (Map<String, Object> m : resultado) {
for (String k : m.keySet()) {
if (m.get(k) instanceof Date) {
m.put(k, sdf.format((Date) m.get(k)));
}
}
}
return ResponseUtil.ok().put("dados", resultado);
}
/**
* Estatísticas por valor com agregação de tempo
*/
@GetMapping("/estatisticasTempo/{eixoX}/{eixoY}/{tipoTempo}")
public ResponseUtil estatisticasTempo(@PathVariable("eixoY") String eixoY, @PathVariable("eixoX") String eixoX, @PathVariable("tipoTempo") String tipoTempo, HttpServletRequest request) {
Map<String, Object> params = new HashMap<>();
params.put("colunaX", eixoX);
params.put("colunaY", eixoY);
params.put("tipoEstatisticaTempo", tipoTempo);
QueryWrapper<AnuncioVaga> queryWrapper = new QueryWrapper<>();
List<Map<String, Object>> resultado = anuncioVagaServico.selecionarValorComTempo(params, queryWrapper);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (Map<String, Object> m : resultado) {
for (String k : m.keySet()) {
if (m.get(k) instanceof Date) {
m.put(k, sdf.format((Date) m.get(k)));
}
}
}
return ResponseUtil.ok().put("dados", resultado);
}
/**
* Estatísticas de grupo
*/
@GetMapping("/estatisticasGrupo/{coluna}")
public ResponseUtil estatisticasGrupo(@PathVariable("coluna") String coluna, HttpServletRequest request) {
Map<String, Object> params = new HashMap<>();
params.put("coluna", coluna);
QueryWrapper<AnuncioVaga> queryWrapper = new QueryWrapper<>();
List<Map<String, Object>> resultado = anuncioVagaServico.selecionarGrupo(params, queryWrapper);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (Map<String, Object> m : resultado) {
for (String k : m.keySet()) {
if (m.get(k) instanceof Date) {
m.put(k, sdf.format((Date) m.get(k)));
}
}
}
return ResponseUtil.ok().put("dados", resultado);
}
/**
* Contagem total de anúncios
*/
@GetMapping("/contagem")
public ResponseUtil contarAnuncios(@RequestParam Map<String, Object> params, AnuncioVaga anuncioVaga, HttpServletRequest request) {
QueryWrapper<AnuncioVaga> queryWrapper = new QueryWrapper<>();
int count = anuncioVagaServico.contar(
QueryWrapperUtil.ordenar(QueryWrapperUtil.entre(QueryWrapperUtil.likeOuIgual(queryWrapper, anuncioVaga), params), params));
return ResponseUtil.ok().put("dados", count);
}
}
Controller de Orientadores
Este controlador gerencia as informações dos orientadores universitários, incluindo autenticação, CRUD, e outras funcionalidades administrativas.
package com.sistemaemprego.controle;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.sistemaemprego.entidade.Orientador;
import com.sistemaemprego.servico.OrientadorServico;
import com.sistemaemprego.servico.TokenServico;
import com.sistemaemprego.servico.DicionarioServico;
import com.sistemaemprego.util.CommonUtil;
import com.sistemaemprego.util.PageUtil;
import com.sistemaemprego.util.ResponseUtil;
import com.sistemaemprego.util.QueryWrapperUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* Orientador
* Endpoint REST para gestão de orientadores.
*/
@RestController
@RequestMapping("/orientadores")
public class OrientadorController {
private static final Logger logger = LoggerFactory.getLogger(OrientadorController.class);
@Autowired
private OrientadorServico orientadorServico;
@Autowired
private TokenServico tokenServico;
@Autowired
private DicionarioServico dicionarioServico;
/**
* Listagem paginada para o backend
*/
@GetMapping("/paginacao")
public ResponseUtil listarPaginadoBackend(@RequestParam Map<String, Object> params, HttpServletRequest request) {
logger.debug("Método paginacao: Controller:{}, params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
String papel = String.valueOf(request.getSession().getAttribute("papel"));
// Aplica filtro de exclusão lógica
params.put("orientadorAtivoStart", 1);
params.put("orientadorAtivoEnd", 1);
CommonUtil.verificarMapa(params);
PageUtil<Orientador> page = orientadorServico.consultarPagina(params);
// Conversão de dados do dicionário
List<Orientador> lista = (List<Orientador>) page.getList();
for (Orientador o : lista) {
dicionarioServico.converterDicionario(o, request);
}
return ResponseUtil.ok().put("dados", page);
}
/**
* Detalhes do orientador (backend)
*/
@GetMapping("/detalhe/{id}")
public ResponseUtil detalheOrientador(@PathVariable("id") Long id, HttpServletRequest request) {
logger.debug("Método detalheOrientador: Controller:{}, id:{}", this.getClass().getName(), id);
Orientador orientador = orientadorServico.selecionarPorId(id);
if (orientador != null) {
// Converte para view para aplicar dicionário
Orientador view = new Orientador(); // Assumindo Orientador já é a entidade/view
BeanUtils.copyProperties(orientador, view);
dicionarioServico.converterDicionario(view, request);
return ResponseUtil.ok().put("dados", view);
} else {
return ResponseUtil.error(511, "Dados não encontrados.");
}
}
/**
* Cria um novo orientador (backend)
*/
@PostMapping("/criar")
public ResponseUtil criarOrientador(@RequestBody Orientador orientador, HttpServletRequest request) {
logger.debug("Método criarOrientador: Controller:{}, orientador:{}", this.getClass().getName(), orientador.toString());
QueryWrapper<Orientador> queryWrapper = new QueryWrapper<Orientador>()
.eq("nomeUsuario", orientador.getNomeUsuario())
.or()
.eq("telefoneOrientador", orientador.getTelefoneOrientador())
.or()
.eq("cpfOrientador", orientador.getCpfOrientador())
.eq("ativo", 1); // Apenas ativos
logger.info("SQL: {}", queryWrapper.getSqlSegment());
Orientador orientadorExistente = orientadorServico.selecionarUm(queryWrapper);
if (orientadorExistente == null) {
orientador.setAtivo(1); // Ativo por padrão
orientador.setDataCriacao(new Date());
orientador.setSenha("123456"); // Senha padrão
orientadorServico.inserir(orientador);
return ResponseUtil.ok();
} else {
return ResponseUtil.error(511, "Nome de usuário, telefone ou CPF já em uso.");
}
}
/**
* Atualiza um orientador (backend)
*/
@PutMapping("/atualizar")
public ResponseUtil atualizarOrientador(@RequestBody Orientador orientador, HttpServletRequest request) {
logger.debug("Método atualizarOrientador: Controller:{}, orientador:{}", this.getClass().getName(), orientador.toString());
Orientador orientadorAntigo = orientadorServico.selecionarPorId(orientador.getId());
if (orientador.getFotoOrientador() == null || orientador.getFotoOrientador().isEmpty()) {
orientador.setFotoOrientador(null);
}
orientadorServico.atualizarPorId(orientador); // Atualização completa
return ResponseUtil.ok();
}
/**
* Exclui um ou mais orientadores (exclusão lógica)
*/
@DeleteMapping("/excluir")
public ResponseUtil excluirOrientadores(@RequestBody Integer[] ids, HttpServletRequest request) {
logger.debug("Método excluirOrientadores: Controller:{}, ids:{}", this.getClass().getName(), Arrays.toString(ids));
List<Orientador> listaParaExcluir = new ArrayList<>();
for (Integer id : ids) {
Orientador orientador = new Orientador();
orientador.setId(id.longValue());
orientador.setAtivo(2); // Inativa o registro
listaParaExcluir.add(orientador);
}
if (!listaParaExcluir.isEmpty()) {
orientadorServico.atualizarEmLotePorId(listaParaExcluir);
}
return ResponseUtil.ok();
}
/**
* Login do orientador
*/
@PostMapping(value = "/login")
public ResponseUtil loginOrientador(String nomeUsuario, String senha, String captcha, HttpServletRequest request) {
Orientador orientador = orientadorServico.selecionarUm(new QueryWrapper<Orientador>().eq("nomeUsuario", nomeUsuario));
if (orientador == null || !orientador.getSenha().equals(senha))
return ResponseUtil.error("Usuário ou senha incorretos.");
else if (orientador.getAtivo() != 1) // Verifica se o orientador está ativo
return ResponseUtil.error("Conta inativa ou excluída.");
String token = tokenServico.gerarToken(orientador.getId(), nomeUsuario, "orientador", "Orientador");
ResponseUtil r = ResponseUtil.ok();
r.put("token", token);
r.put("papel", "Orientador");
r.put("nomeUsuario", orientador.getNomeOrientador());
r.put("tabela", "orientadores");
r.put("idUsuario", orientador.getId());
return r;
}
/**
* Registro de novo orientador
*/
@PostMapping(value = "/registrar")
public ResponseUtil registrarOrientador(@RequestBody Orientador orientador, HttpServletRequest request) {
QueryWrapper<Orientador> queryWrapper = new QueryWrapper<Orientador>()
.eq("nomeUsuario", orientador.getNomeUsuario())
.or()
.eq("telefoneOrientador", orientador.getTelefoneOrientador())
.or()
.eq("cpfOrientador", orientador.getCpfOrientador())
.eq("ativo", 1); // Verifica apenas em registros ativos
Orientador orientadorExistente = orientadorServico.selecionarUm(queryWrapper);
if (orientadorExistente != null)
return ResponseUtil.error("Nome de usuário, telefone ou CPF já em uso.");
orientador.setAtivo(1);
orientador.setDataCriacao(new Date());
orientadorServico.inserir(orientador);
return ResponseUtil.ok();
}
/**
* Resetar senha para o padrão
*/
@GetMapping(value = "/resetarSenha")
public ResponseUtil resetarSenha(@RequestParam Integer id, HttpServletRequest request) {
Orientador orientador = orientadorServico.selecionarPorId(id.longValue());
if (orientador != null) {
orientador.setSenha("123456");
orientadorServico.atualizarPorId(orientador);
return ResponseUtil.ok();
}
return ResponseUtil.error("Orientador não encontrado.");
}
/**
* Alterar senha
*/
@GetMapping(value = "/alterarSenha")
public ResponseUtil alterarSenha(String senhaAntiga, String novaSenha, HttpServletRequest request) {
Long idUsuarioLogado = (Long) request.getSession().getAttribute("idUsuario");
if (idUsuarioLogado == null) {
return ResponseUtil.error(401, "Sessão inválida, por favor, faça login novamente.");
}
Orientador orientador = orientadorServico.selecionarPorId(idUsuarioLogado);
if (novaSenha == null || novaSenha.isEmpty()) {
return ResponseUtil.error("A nova senha não pode ser vazia.");
}
if (!senhaAntiga.equals(orientador.getSenha())) {
return ResponseUtil.error("A senha antiga está incorreta.");
}
if (novaSenha.equals(orientador.getSenha())) {
return ResponseUtil.error("A nova senha não pode ser igual à senha antiga.");
}
orientador.setSenha(novaSenha);
orientadorServico.atualizarPorId(orientador);
return ResponseUtil.ok("Senha alterada com sucesso!");
}
/**
* Esqueceu a senha (reset via nome de usuário)
*/
@GetMapping(value = "/esqueceuSenha")
public ResponseUtil esqueceuSenha(String nomeUsuario, HttpServletRequest request) {
Orientador orientador = orientadorServico.selecionarUm(new QueryWrapper<Orientador>().eq("nomeUsuario", nomeUsuario));
if (orientador != null) {
orientador.setSenha("123456"); // Reset para senha padrão
orientadorServico.atualizarPorId(orientador);
return ResponseUtil.ok("Senha resetada para '123456'.");
} else {
return ResponseUtil.error("Conta de usuário não encontrada.");
}
}
/**
* Obter informações do orientador logado (sessão)
*/
@GetMapping("/sessao")
public ResponseUtil obterOrientadorSessao(HttpServletRequest request) {
Long id = (Long) request.getSession().getAttribute("idUsuario");
if (id == null) {
return ResponseUtil.error(401, "Nenhum usuário logado na sessão.");
}
Orientador orientador = orientadorServico.selecionarPorId(id);
if (orientador != null) {
Orientador view = new Orientador();
BeanUtils.copyProperties(orientador, view);
dicionarioServico.converterDicionario(view, request);
return ResponseUtil.ok().put("dados", view);
} else {
return ResponseUtil.error(511, "Dados do orientador logado não encontrados.");
}
}
/**
* Logout
*/
@GetMapping(value = "/logout")
public ResponseUtil logout(HttpServletRequest request) {
request.getSession().invalidate();
return ResponseUtil.ok("Logout realizado com sucesso.");
}
/**
* Listagem paginada para o frontend (acesso público)
*/
@GetMapping("/lista")
public ResponseUtil listarPaginadoFrontend(@RequestParam Map<String, Object> params, HttpServletRequest request) {
logger.debug("Método lista: Controller:{}, params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
CommonUtil.verificarMapa(params);
PageUtil<Orientador> page = orientadorServico.consultarPagina(params);
List<Orientador> lista = (List<Orientador>) page.getList();
for (Orientador o : lista) {
dicionarioServico.converterDicionario(o, request);
}
return ResponseUtil.ok().put("dados", page);
}
/**
* Detalhes do orientador (frontend, acesso público)
*/
@GetMapping("/detalhePublico/{id}")
public ResponseUtil detalheOrientadorPublico(@PathVariable("id") Long id, HttpServletRequest request) {
logger.debug("Método detalheOrientadorPublico: Controller:{}, id:{}", this.getClass().getName(), id);
Orientador orientador = orientadorServico.selecionarPorId(id);
if (orientador != null) {
Orientador view = new Orientador();
BeanUtils.copyProperties(orientador, view);
dicionarioServico.converterDicionario(view, request);
return ResponseUtil.ok().put("dados", view);
} else {
return ResponseUtil.error(511, "Dados não encontrados.");
}
}
/**
* Adiciona um novo orientador (frontend)
*/
@PostMapping("/adicionar")
public ResponseUtil adicionarOrientador(@RequestBody Orientador orientador, HttpServletRequest request) {
logger.debug("Método adicionarOrientador: Controller:{}, orientador:{}", this.getClass().getName(), orientador.toString());
QueryWrapper<Orientador> queryWrapper = new QueryWrapper<Orientador>()
.eq("nomeUsuario", orientador.getNomeUsuario())
.or()
.eq("telefoneOrientador", orientador.getTelefoneOrientador())
.or()
.eq("cpfOrientador", orientador.getCpfOrientador())
.eq("ativo", 1); // Verifica apenas em registros ativos
Orientador orientadorExistente = orientadorServico.selecionarUm(queryWrapper);
if (orientadorExistente == null) {
orientador.setAtivo(1);
orientador.setDataCriacao(new Date());
orientador.setSenha("123456");
orientadorServico.inserir(orientador);
return ResponseUtil.ok();
} else {
return ResponseUtil.error(511, "Nome de usuário, telefone ou CPF já em uso.");
}
}
}