Spring
07/09/2019 14:48
0
Boa tarde.

Pessoal, estou desenvolvendo um sistemas que dispoe de deletar um convidado do banco de dados.
Porem quando eu aperto no botão para deletar nao é feita a exclusão no banco de dados e nao gera erro, isso começou a acontecer depois que implementei o spring security.
alguem pode me ajudar?

Segue minhas classes:

Controller:
package com.eventosapp.controllers;
import java.util.ArrayList;
import javax.validation.Valid;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;
import com.eventosapp.models.Convidado;
import com.eventosapp.models.Evento;
//import com.eventosapp.models.Usuario;
import com.eventosapp.repository.ConvidadoRepository;
import com.eventosapp.repository.EventoRepository;
//import com.eventosapp.repository.UsuarioRepository;
@Controller
public class EventoController {
@Autowired
private EventoRepository eventoRepository;
@Autowired
private ConvidadoRepository convidadoRepository;

@GetMapping("/cadastrarUsuario")
public String cadastrarUsuario() {
return "cadastrarUsuario";
}
@GetMapping("/login")
public String login() {
return "login";
}
@GetMapping(value = "/")
public String index() {
return "home";
}
@RequestMapping(value = "/cadastrarEvento", method = RequestMethod.GET)
public String form() {
return "evento/formEvento";
}
@RequestMapping(value = "/cadastrarEvento", method = RequestMethod.POST)
public String form(@Valid Evento evento, BindingResult result, RedirectAttributes attributes) {
if (result.hasErrors()) {
attributes.addFlashAttribute("mensagem", "Verifique os campos!");
return "redirect:/cadastrarEvento";
}
eventoRepository.save(evento);
attributes.addFlashAttribute("mensagem", "Evento adicionado com sucesso!");
return "redirect:/cadastrarEvento";
}
@RequestMapping("/eventos")
public ModelAndView listaEventos() {
ModelAndView modelandView = new ModelAndView("evento/eventos");
Iterable<Evento> eventos = eventoRepository.findAll();
modelandView.addObject("eventos", eventos);
return modelandView;
}
@RequestMapping(value = "/{codigo}", method = RequestMethod.GET)
public ModelAndView detalheEvento(@PathVariable("codigo") long codigo) {
Evento evento = eventoRepository.findByCodigo(codigo);
ModelAndView modelandView = new ModelAndView("evento/detalheEvento");
modelandView.addObject("evento", evento);
Iterable<Convidado> convidado = convidadoRepository.findByEvento(evento);
modelandView.addObject("convidado", convidado);
return modelandView;
}
@RequestMapping("/deletarEvento")
public String deletarEvento(long codigo) {
Evento evento = eventoRepository.findByCodigo(codigo);
eventoRepository.delete(evento);
return "redirect:/eventos";
}
@RequestMapping(value = "/{codigo}", method = RequestMethod.POST)
public String detalheEventoPost(@PathVariable("codigo") long codigo, @Valid Convidado convidado,
BindingResult result, RedirectAttributes attributes) {
if (result.hasErrors()) {
attributes.addFlashAttribute("mensagem", "Verifique os campos!");
return "redirect:/{codigo}";
}
Evento evento = eventoRepository.findByCodigo(codigo);
convidado.setEvento(evento);
convidadoRepository.save(convidado);
attributes.addFlashAttribute("mensagem", "Convidado adicionado com sucesso!");
return "redirect:/{codigo}";
}
@RequestMapping(value = "editarEvento{codigo}", method = RequestMethod.GET)
public ModelAndView editarEvento(@PathVariable("codigo") long codigo) {// no pathvariable uso o id que coloquei no
// html na grade editar <td><a
// th:href="@{/editarpessoa/{idpessoa}(idpessoa=${pessoa.id})}">Editar</a></td>
Evento evento = eventoRepository.findByCodigo(codigo);// O findById retona um Optional.
ModelAndView modelAndView = new ModelAndView("evento/editarEvento");
modelAndView.addObject("evento", evento);
return modelAndView;
}
@RequestMapping(value = "editarEvento{codigo}", method = RequestMethod.POST)
public String editarEventos(@Valid Evento evento, BindingResult result, RedirectAttributes attributes) {
if (result.hasErrors()) {
attributes.addFlashAttribute("mensagem", "Dados não alterados!");
return "redirect:/eventos";
}
eventoRepository.save(evento);
attributes.addFlashAttribute("mensagem", "Dados alterados com sucesso!!");
return "redirect:/eventos";
}

@RequestMapping("/deletarConvidado")
public String deletarConvidado(String rg) {
Convidado convidado = convidadoRepository.findByRg(rg);
convidadoRepository.delete(convidado);

Evento evento = convidado.getEvento();
long codigoLong = evento.getCodigo();
String codigo = ""+(codigoLong);
return "redirect:/" + codigo;
}

}






Repository:
package com.eventosapp.repository;
import org.springframework.data.repository.CrudRepository;
import com.eventosapp.models.Convidado;
import com.eventosapp.models.Evento;
public interface ConvidadoRepository extends CrudRepository<Convidado, String>{

Iterable<Convidado> findByEvento(Evento evento);
Convidado findByRg(String rg);

}




Security:

package com.eventosapp.security;
import javax.transaction.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.User;
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.Repository;
import org.springframework.stereotype.Service;
import com.eventosapp.models.Usuario;
import com.eventosapp.repository.UsuarioRepository;
@Repository
@Transactional
public class ImplementsUserDetailsService implements UserDetailsService {
@Autowired
private UsuarioRepository usuarioRepository;

@Override
public UserDetails loadUserByUsername(String login) throws UsernameNotFoundException {
Usuario usuario = usuarioRepository.findByLogin(login);

if(usuario == null) {
throw new UsernameNotFoundException("Usuário não encontrado");
}
return new User(usuario.getUsername(), usuario.getSenha(), true, true, true, true, usuario.getAuthorities());
}
}



package com.eventosapp.security;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

@Autowired
private ImplementsUserDetailsService userDetailsService;


@Override
protected void configure(final HttpSecurity http) throws Exception{
http
.csrf()
.disable()
.authorizeRequests()
.antMatchers("/deletarEvento").hasRole("ADMIN")

.antMatchers(HttpMethod.POST, "/cadastrarEvento").hasRole("ADMIN")

.antMatchers(HttpMethod.POST, "/{codigo}").hasRole("ADMIN")

.antMatchers(HttpMethod.POST, "/editarEvento/{codigo}").hasRole("ADMIN")
.antMatchers(HttpMethod.GET, "/editarEvento/{codigo}").hasRole("ADMIN")

.antMatchers(HttpMethod.GET, "/login").permitAll()

.antMatchers(HttpMethod.GET, "/cadastrarUsuario").permitAll()

.anyRequest()
.authenticated()
.and()
.formLogin()
.loginPage("/login")
.usernameParameter("login")
.passwordParameter("senha")
.and()
.logout()
.logoutRequestMatcher(new AntPathRequestMatcher("/logout")).permitAll();
}
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception{
auth.userDetailsService(userDetailsService)
.passwordEncoder(new BCryptPasswordEncoder());
}

@Override 
public void configure(WebSecurity web) throws Exception{
web
.ignoring()
.antMatchers("/materialize/**","/style/**");
}
}
Tags: programação, Springboot, SpringSecurity


0
É muito comum haver erros silenciosos na persistência. Tente executar um flush ao final do salvamento e veja se está dando algum erro.



Ainda não faz parte da comunidade???

Para se registrar, clique aqui.

Podcast da itexto



Aprenda Groovy e Grails, Spring e mais com a Formação itexto!

Livro de Spring


/dev/All

Os melhores blogs de TI
em um único lugar!

 
Spring Brasil é mantido por itexto Consultoria.
Em caso de problemas contacte Henrique Lobo Weissmann (Kico) por e-mail: kico@itexto.com.br
Todo o conteúdo presente neste site adota o Creative Commons como licença padrão.