From 75652ff0a098ad2a8d42293c942bfd543a290c2a Mon Sep 17 00:00:00 2001 From: vitor.pacheco Date: Fri, 26 Sep 2014 10:55:25 +0000 Subject: [PATCH] Teste #3330: Campos Obrigatórios --- Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/AvaliacaoController.java | 20 ++++++++++---------- Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/CriteriosController.java | 612 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/FaixaController.java | 658 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/GruposController.java | 256 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------------------------------------------------------------------------------------------------------------------- Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/PainelController.java | 32 ++++++++++++++++---------------- Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/ParametroCalculoController.java | 22 +++++++++++----------- Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/PermissoesController.java | 242 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------------------------------------------------------------------------------------------------------- Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/RecomendacaoController.java | 30 +++++++++++++++--------------- Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/TestesController.java | 88 ++++++++++++++++++++++++++++++++++++++++++++-------------------------------------------- Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/TiposTesteController.java | 218 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------------------------------------------------------------------------------------------- Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/UrlController.java | 2 +- Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/UsuariosController.java | 520 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 12 files changed, 1350 insertions(+), 1350 deletions(-) diff --git a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/AvaliacaoController.java b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/AvaliacaoController.java index 0d79416..8e4b908 100644 --- a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/AvaliacaoController.java +++ b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/AvaliacaoController.java @@ -132,7 +132,7 @@ public class AvaliacaoController { ParametroCalculo parametroCalculo = paramDao .getLastParametrosCalculo(); - + salvarAvaliacao(relatorioAvaliacao, parametroCalculo); // obter as diretrizes e níveis de conformidade @@ -159,7 +159,7 @@ public class AvaliacaoController { } somaPesosRecomendacoes = somaPesosRecomendacoes + recomendacao.getPeso(); - + if(somatorioPesosCriterios>0){ somatorioNotaRecomendacoes = ((somatorioNotaTeste / somatorioPesosCriterios) * recomendacao.getPeso()) + somatorioNotaRecomendacoes; } @@ -191,7 +191,7 @@ public class AvaliacaoController { /** * Função REST que executa uma avaliação e devolve seu resultado no formato * JSON - * + * * @param relatorioAvaliacao */ @Post("/calcular-nota") @@ -202,8 +202,8 @@ public class AvaliacaoController { String fullContextPath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + request.getContextPath(); - - if (relatorioAvaliacao.getRecomendacoes()!=null + + if (relatorioAvaliacao.getRecomendacoes()!=null && relatorioAvaliacao.getRecomendacoes().size() > 0 && relatorioAvaliacao.getDate() != null && relatorioAvaliacao.getUrl() != null) { @@ -247,21 +247,21 @@ public class AvaliacaoController { result.use(Results.json()).withoutRoot().from(resultadoAvaliacao) .serialize(); } - + private Avaliacao salvarAvaliacao(RelatorioAvaliacao relatorioAvaliacao, ParametroCalculo parametroCalculo){ - + try { relatorioAvaliacao.setUrl(URLNormalizer.normalize(relatorioAvaliacao.getUrl())); } catch (MalformedURLException e) { System.out.println("Erro ao tentar normalizar a URL do Relatorio de Avaliacao"); e.printStackTrace(); } - + Avaliacao avaliacao = new Avaliacao(); avaliacao.setDataAvaliacao(relatorioAvaliacao.getDate()); avaliacao.setParametroCalculo(parametroCalculo); avaliacao.setQtdeLinhas(relatorioAvaliacao.getQtdeLinhas()); - + Url url = daoUrl.getStringUrl(relatorioAvaliacao.getUrl()); if (url == null) { @@ -269,7 +269,7 @@ public class AvaliacaoController { url.setUrl(relatorioAvaliacao.getUrl()); daoUrl.save(url); } - + avaliacao.setUrl(url); avaliacao = new LeitorXML().lerResultadosXML(relatorioAvaliacao, avaliacao); dao.save(avaliacao); diff --git a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/CriteriosController.java b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/CriteriosController.java index 184af6f..a57002b 100644 --- a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/CriteriosController.java +++ b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/CriteriosController.java @@ -1,306 +1,306 @@ -package br.com.eselo.controller; - -import java.util.List; - -import br.com.caelum.vraptor.Get; -import br.com.caelum.vraptor.Path; -import br.com.caelum.vraptor.Post; -import br.com.caelum.vraptor.Put; -import br.com.caelum.vraptor.Resource; -import br.com.caelum.vraptor.Result; -import br.com.caelum.vraptor.Validator; -import br.com.caelum.vraptor.validator.ValidationMessage; -import br.com.eselo.annotations.Restrito; -import br.com.eselo.component.CopiadorParametroCalculo; -import br.com.eselo.component.UsuarioWeb; -import br.com.eselo.dao.CriterioDAO; -import br.com.eselo.dao.ParametroCalculoDAO; -import br.com.eselo.dao.RecomendacaoDAO; -import br.com.eselo.dao.TipoTesteDAO; -import br.com.eselo.model.Criterio; -import br.com.eselo.model.ParametroCalculo; -import br.com.eselo.model.Recomendacao; -import br.com.eselo.model.TipoTeste; - -@Resource -public class CriteriosController { - - private final CriterioDAO dao; - private final ParametroCalculoDAO paDAO; - private final Result result; - private final Validator validator; - private final UsuarioWeb usuarioWeb; - - public CriteriosController(CriterioDAO _dao, ParametroCalculoDAO _paDAO, - Result _result, Validator _validator, UsuarioWeb _usuarioWeb) { - this.dao = _dao; - this.paDAO = _paDAO; - this.result = _result; - this.validator = _validator; - this.usuarioWeb = _usuarioWeb; - } - - @Get("/criterio/novo/{id}") - @Restrito(descricao = "CRITERIO_ADICIONAR") - public Criterio novo(Long id) { - Recomendacao recomendacao = new RecomendacaoDAO(dao.getSession()) - .load(id); - Criterio criterio = new Criterio(); - criterio.setRecomendacao(recomendacao); - - result.include("parametroCalculoId", criterio.getRecomendacao() - .getParametroCalculo().getId()); - result.include("parametroCalculo", criterio.getRecomendacao() - .getParametroCalculo()); - result.include("recomendacao", criterio.getRecomendacao()); - result.include("recomendacaoId", criterio.getRecomendacao().getId()); - - populateSelectLists(); - - return criterio; - } - - @Get("/criterios/form/{id}") - @Restrito(descricao = "CRITERIO_ATUALIZAR") - public Criterio form(Long id) { - Criterio criterio = dao.load(id); - result.include("recomendacaoId", criterio.getRecomendacao().getId()); - result.include("parametroCalculo", criterio.getRecomendacao() - .getParametroCalculo()); - result.include("tipoTeste", criterio.getTipoTeste()); - populateSelectLists(); - - return criterio; - } - - @Post("/criterio") - @Restrito(descricao = "CRITERIO_ADICIONAR") - public void adicionar(Criterio criterio) { - - criterio.setRecomendacao(new RecomendacaoDAO(dao.getSession()) - .load(criterio.getRecomendacao().getId())); - - validarCriterio(criterio); - - result.include("recomendacaoId", criterio.getRecomendacao().getId()); - result.include("parametroCalculo", criterio.getRecomendacao() - .getParametroCalculo()); - result.include("tipoTeste", criterio.getTipoTeste()); - populateSelectLists(); - - validator.onErrorUsePageOf(CriteriosController.class).novo( - criterio.getRecomendacao().getId()); - - this.criarNovoParametroAvaliacao(criterio, - ParametroCalculoController.MODO_ADD); - - result.include("mensagem", "Critério salvo com sucesso."); - result.redirectTo(RecomendacaoController.class).form( - criterio.getRecomendacao().getId()); - } - - @Put("/criterio") - @Restrito(descricao = "CRITERIO_ATUALIZAR") - public void atualizar(Criterio criterio) { - criterio.setRecomendacao(new RecomendacaoDAO(dao.getSession()) - .load(criterio.getRecomendacao().getId())); - - @SuppressWarnings("unchecked") - List tipoTestes = (List) dao.getAllTipoTeste(); - Criterio criterioCadastrado = dao.load(criterio.getId()); - - - result.include("recomendacaoId", criterio.getRecomendacao().getId()); - result.include("parametroCalculo", criterio.getRecomendacao() - .getParametroCalculo()); - result.include("tipoTeste", criterio.getTipoTeste()); - result.include("tipoTesteList", tipoTestes); - - validarCriterio(criterio); - - validator.onErrorUsePageOf(CriteriosController.class).form( - criterioCadastrado.getId()); - - if(validarAtualizacaoCriterio(criterio)){ - - criarNovoParametroAvaliacao(criterio,ParametroCalculoController.MODO_EDIT); - result.include("mensagem", "Critério salvo com sucesso."); - }else{ - criterioCadastrado.setDescricao(criterio.getDescricao()); - dao.update(criterioCadastrado); - result.include("mensagem", "Nenhum campo foi alterado."); - } - - result.redirectTo(CriteriosController.class).form( - criterio.getId()); - } - - @Path("/criterio/delete/{id}") - @Restrito(descricao = "CRITERIO_EXCLUIR") - public void excluir(Long id) { - Criterio criteiro = dao.load(id); - - criarNovoParametroAvaliacao(criteiro, - ParametroCalculoController.MODO_DELETE); - - result.include("mensagem", "Criteiro excluída com sucesso."); - result.redirectTo(ParametroCalculoController.class).index(1); - } - - private void criarNovoParametroAvaliacao(Criterio criterio, int tipo) { - ParametroCalculo ultimoParametroAvaliacao = paDAO - .getLastParametrosCalculo(); - boolean ok = false; - - switch (tipo) { - case ParametroCalculoController.MODO_ADD: - for (Recomendacao recomendacao : ultimoParametroAvaliacao - .getRecomendacoes()) { - if (recomendacao.getId().equals( - criterio.getRecomendacao().getId())) { - recomendacao.addCriterio(criterio); - ok = true; - break; - } - } - - break; - - case ParametroCalculoController.MODO_EDIT: - for (Recomendacao recomendacao : ultimoParametroAvaliacao - .getRecomendacoes()) { - if (recomendacao.getId().equals( - criterio.getRecomendacao().getId())) { - for (Criterio c : recomendacao.getCriterios()) { - if (criterio.getId().equals(c.getId())) { - c.setDescricao(criterio.getDescricao()); - c.setFaixas(criterio.getFaixas()); - c.setId(criterio.getId()); - c.setNumeroCriterio(criterio.getNumeroCriterio()); - c.setPeso(criterio.getPeso()); - c.setRecomendacao(criterio.getRecomendacao()); - c.setTipoTeste(criterio.getTipoTeste()); - - ok = true; - break; - } - } - } - } - - break; - - case ParametroCalculoController.MODO_DELETE: - for (Recomendacao recomendacao : ultimoParametroAvaliacao - .getRecomendacoes()) { - if (recomendacao.getId().equals( - criterio.getRecomendacao().getId())) { - recomendacao.removeCriterio(criterio); - ok = true; - break; - } - } - break; - } - - if (ok) { - new CopiadorParametroCalculo().criarNovoParametroCalculo( - ultimoParametroAvaliacao, usuarioWeb, dao.getSession()); - } - } - - private void validarCriterio(Criterio criterio) { - - if (criterio.getNumeroCriterio() == null) { - validator.add(new ValidationMessage( - "É obrigatório informar o número da recomendação.", - "criteiro.numeroCriterio")); - } else if (hasNumeroCriterioRecomendacaoAtual(criterio)) { - validator.add(new ValidationMessage( - "Já existe um critério com esse número. Informe outro número para o critério.", - "criteiro.numeroCriteiro")); - } else if (criterio.getPeso() == null) { - validator.add(new ValidationMessage( - "É obrigatório informar o peso do criteiro.", - "criteiro.peso")); - } else if (criterio.getPeso() <= 0) { - validator - .add(new ValidationMessage( - "O peso do criteiro deve ser maior que 0.", - "criteiro.peso")); - } else if (criterio.getDescricao() == null) { - validator.add(new ValidationMessage( - "É obrigatório informar a descrição do criteiro.", - "criteiro.descricao")); - } else if (criterio.getTipoTeste().getId() == null) { - validator.add(new ValidationMessage( - "É obrigatório informar o Tipo de teste.", - "criterio.tipoTeste")); - } else { - criterio.setTipoTeste(new TipoTesteDAO(dao.getSession()) - .load(criterio.getTipoTeste().getId())); - } - } - - private boolean validarAtualizacaoCriterio(Criterio criterio) { - - boolean alteracao = false; - - Criterio criterioCadastrado = dao.load(criterio.getId()); - - if (criterio.getNumeroCriterio().compareTo(criterioCadastrado.getNumeroCriterio())!=0) { - alteracao = true; - } else if (criterio.getPeso().compareTo(criterioCadastrado.getPeso()) !=0) { - alteracao = true; - } else if (criterio.getDescricao().compareToIgnoreCase(criterioCadastrado.getDescricao()) != 0) { - alteracao = true; - } else if (criterio.getTipoTeste().getId().compareTo(criterioCadastrado.getTipoTeste().getId())!=0) { - alteracao = true; - } - - return alteracao; - } - - /** - * Recebe um critério antes de ser cadastrad0 e verifica se ja existe um - * criterio ativo com o mesmo numero. - * - * @param criterio - * @return boolean - */ - private boolean hasNumeroCriterioRecomendacaoAtual(Criterio criterio) { - boolean retorno = false; - - if (criterio.getDescricao() != null - && criterio.getNumeroCriterio() != null - && criterio.getPeso() != null - && criterio.getRecomendacao() != null - && criterio.getTipoTeste().getId() != null) { - Recomendacao recomendacao = criterio.getRecomendacao(); - - List listaCadastrada = dao.listAllAtivas(recomendacao); - - for (Criterio criterioCadastrado : listaCadastrada) { - if (criterioCadastrado.getNumeroCriterio().longValue() == criterio - .getNumeroCriterio().longValue()) { - if (criterio.getId() != null) { - if (criterioCadastrado.getId().longValue() != criterio - .getId().longValue()) { - return true; - } - } else { - return true; - } - } - } - - } - - return retorno; - } - - private void populateSelectLists() { - result.include("tipoTesteList", dao.getAllTipoTeste()); - } - -} +package br.com.eselo.controller; + +import java.util.List; + +import br.com.caelum.vraptor.Get; +import br.com.caelum.vraptor.Path; +import br.com.caelum.vraptor.Post; +import br.com.caelum.vraptor.Put; +import br.com.caelum.vraptor.Resource; +import br.com.caelum.vraptor.Result; +import br.com.caelum.vraptor.Validator; +import br.com.caelum.vraptor.validator.ValidationMessage; +import br.com.eselo.annotations.Restrito; +import br.com.eselo.component.CopiadorParametroCalculo; +import br.com.eselo.component.UsuarioWeb; +import br.com.eselo.dao.CriterioDAO; +import br.com.eselo.dao.ParametroCalculoDAO; +import br.com.eselo.dao.RecomendacaoDAO; +import br.com.eselo.dao.TipoTesteDAO; +import br.com.eselo.model.Criterio; +import br.com.eselo.model.ParametroCalculo; +import br.com.eselo.model.Recomendacao; +import br.com.eselo.model.TipoTeste; + +@Resource +public class CriteriosController { + + private final CriterioDAO dao; + private final ParametroCalculoDAO paDAO; + private final Result result; + private final Validator validator; + private final UsuarioWeb usuarioWeb; + + public CriteriosController(CriterioDAO _dao, ParametroCalculoDAO _paDAO, + Result _result, Validator _validator, UsuarioWeb _usuarioWeb) { + this.dao = _dao; + this.paDAO = _paDAO; + this.result = _result; + this.validator = _validator; + this.usuarioWeb = _usuarioWeb; + } + + @Get("/criterio/novo/{id}") + @Restrito(descricao = "CRITERIO_ADICIONAR") + public Criterio novo(Long id) { + Recomendacao recomendacao = new RecomendacaoDAO(dao.getSession()) + .load(id); + Criterio criterio = new Criterio(); + criterio.setRecomendacao(recomendacao); + + result.include("parametroCalculoId", criterio.getRecomendacao() + .getParametroCalculo().getId()); + result.include("parametroCalculo", criterio.getRecomendacao() + .getParametroCalculo()); + result.include("recomendacao", criterio.getRecomendacao()); + result.include("recomendacaoId", criterio.getRecomendacao().getId()); + + populateSelectLists(); + + return criterio; + } + + @Get("/criterios/form/{id}") + @Restrito(descricao = "CRITERIO_ATUALIZAR") + public Criterio form(Long id) { + Criterio criterio = dao.load(id); + result.include("recomendacaoId", criterio.getRecomendacao().getId()); + result.include("parametroCalculo", criterio.getRecomendacao() + .getParametroCalculo()); + result.include("tipoTeste", criterio.getTipoTeste()); + populateSelectLists(); + + return criterio; + } + + @Post("/criterio") + @Restrito(descricao = "CRITERIO_ADICIONAR") + public void adicionar(Criterio criterio) { + + criterio.setRecomendacao(new RecomendacaoDAO(dao.getSession()) + .load(criterio.getRecomendacao().getId())); + + validarCriterio(criterio); + + result.include("recomendacaoId", criterio.getRecomendacao().getId()); + result.include("parametroCalculo", criterio.getRecomendacao() + .getParametroCalculo()); + result.include("tipoTeste", criterio.getTipoTeste()); + populateSelectLists(); + + validator.onErrorUsePageOf(CriteriosController.class).novo( + criterio.getRecomendacao().getId()); + + this.criarNovoParametroAvaliacao(criterio, + ParametroCalculoController.MODO_ADD); + + result.include("mensagem", "Critério salvo com sucesso."); + result.redirectTo(RecomendacaoController.class).form( + criterio.getRecomendacao().getId()); + } + + @Put("/criterio") + @Restrito(descricao = "CRITERIO_ATUALIZAR") + public void atualizar(Criterio criterio) { + criterio.setRecomendacao(new RecomendacaoDAO(dao.getSession()) + .load(criterio.getRecomendacao().getId())); + + @SuppressWarnings("unchecked") + List tipoTestes = (List) dao.getAllTipoTeste(); + Criterio criterioCadastrado = dao.load(criterio.getId()); + + + result.include("recomendacaoId", criterio.getRecomendacao().getId()); + result.include("parametroCalculo", criterio.getRecomendacao() + .getParametroCalculo()); + result.include("tipoTeste", criterio.getTipoTeste()); + result.include("tipoTesteList", tipoTestes); + + validarCriterio(criterio); + + validator.onErrorUsePageOf(CriteriosController.class).form( + criterioCadastrado.getId()); + + if(validarAtualizacaoCriterio(criterio)){ + + criarNovoParametroAvaliacao(criterio,ParametroCalculoController.MODO_EDIT); + result.include("mensagem", "Critério salvo com sucesso."); + }else{ + criterioCadastrado.setDescricao(criterio.getDescricao()); + dao.update(criterioCadastrado); + result.include("mensagem", "Nenhum campo foi alterado."); + } + + result.redirectTo(CriteriosController.class).form( + criterio.getId()); + } + + @Path("/criterio/delete/{id}") + @Restrito(descricao = "CRITERIO_EXCLUIR") + public void excluir(Long id) { + Criterio criteiro = dao.load(id); + + criarNovoParametroAvaliacao(criteiro, + ParametroCalculoController.MODO_DELETE); + + result.include("mensagem", "Criteiro excluída com sucesso."); + result.redirectTo(ParametroCalculoController.class).index(1); + } + + private void criarNovoParametroAvaliacao(Criterio criterio, int tipo) { + ParametroCalculo ultimoParametroAvaliacao = paDAO + .getLastParametrosCalculo(); + boolean ok = false; + + switch (tipo) { + case ParametroCalculoController.MODO_ADD: + for (Recomendacao recomendacao : ultimoParametroAvaliacao + .getRecomendacoes()) { + if (recomendacao.getId().equals( + criterio.getRecomendacao().getId())) { + recomendacao.addCriterio(criterio); + ok = true; + break; + } + } + + break; + + case ParametroCalculoController.MODO_EDIT: + for (Recomendacao recomendacao : ultimoParametroAvaliacao + .getRecomendacoes()) { + if (recomendacao.getId().equals( + criterio.getRecomendacao().getId())) { + for (Criterio c : recomendacao.getCriterios()) { + if (criterio.getId().equals(c.getId())) { + c.setDescricao(criterio.getDescricao()); + c.setFaixas(criterio.getFaixas()); + c.setId(criterio.getId()); + c.setNumeroCriterio(criterio.getNumeroCriterio()); + c.setPeso(criterio.getPeso()); + c.setRecomendacao(criterio.getRecomendacao()); + c.setTipoTeste(criterio.getTipoTeste()); + + ok = true; + break; + } + } + } + } + + break; + + case ParametroCalculoController.MODO_DELETE: + for (Recomendacao recomendacao : ultimoParametroAvaliacao + .getRecomendacoes()) { + if (recomendacao.getId().equals( + criterio.getRecomendacao().getId())) { + recomendacao.removeCriterio(criterio); + ok = true; + break; + } + } + break; + } + + if (ok) { + new CopiadorParametroCalculo().criarNovoParametroCalculo( + ultimoParametroAvaliacao, usuarioWeb, dao.getSession()); + } + } + + private void validarCriterio(Criterio criterio) { + + if (criterio.getNumeroCriterio() == null) { + validator.add(new ValidationMessage( + "É obrigatório informar o número da recomendação.", + "criteiro.numeroCriterio")); + } else if (hasNumeroCriterioRecomendacaoAtual(criterio)) { + validator.add(new ValidationMessage( + "Já existe um critério com esse número. Informe outro número para o critério.", + "criteiro.numeroCriteiro")); + } else if (criterio.getPeso() == null) { + validator.add(new ValidationMessage( + "É obrigatório informar o peso do criteiro.", + "criteiro.peso")); + } else if (criterio.getPeso() <= 0) { + validator + .add(new ValidationMessage( + "O peso do criteiro deve ser maior que 0.", + "criteiro.peso")); + } else if (criterio.getDescricao() == null) { + validator.add(new ValidationMessage( + "É obrigatório informar a descrição do criteiro.", + "criteiro.descricao")); + } else if (criterio.getTipoTeste().getId() == null) { + validator.add(new ValidationMessage( + "É obrigatório informar o Tipo de teste.", + "criterio.tipoTeste")); + } else { + criterio.setTipoTeste(new TipoTesteDAO(dao.getSession()) + .load(criterio.getTipoTeste().getId())); + } + } + + private boolean validarAtualizacaoCriterio(Criterio criterio) { + + boolean alteracao = false; + + Criterio criterioCadastrado = dao.load(criterio.getId()); + + if (criterio.getNumeroCriterio().compareTo(criterioCadastrado.getNumeroCriterio())!=0) { + alteracao = true; + } else if (criterio.getPeso().compareTo(criterioCadastrado.getPeso()) !=0) { + alteracao = true; + } else if (criterio.getDescricao().compareToIgnoreCase(criterioCadastrado.getDescricao()) != 0) { + alteracao = true; + } else if (criterio.getTipoTeste().getId().compareTo(criterioCadastrado.getTipoTeste().getId())!=0) { + alteracao = true; + } + + return alteracao; + } + + /** + * Recebe um critério antes de ser cadastrad0 e verifica se ja existe um + * criterio ativo com o mesmo numero. + * + * @param criterio + * @return boolean + */ + private boolean hasNumeroCriterioRecomendacaoAtual(Criterio criterio) { + boolean retorno = false; + + if (criterio.getDescricao() != null + && criterio.getNumeroCriterio() != null + && criterio.getPeso() != null + && criterio.getRecomendacao() != null + && criterio.getTipoTeste().getId() != null) { + Recomendacao recomendacao = criterio.getRecomendacao(); + + List listaCadastrada = dao.listAllAtivas(recomendacao); + + for (Criterio criterioCadastrado : listaCadastrada) { + if (criterioCadastrado.getNumeroCriterio().longValue() == criterio + .getNumeroCriterio().longValue()) { + if (criterio.getId() != null) { + if (criterioCadastrado.getId().longValue() != criterio + .getId().longValue()) { + return true; + } + } else { + return true; + } + } + } + + } + + return retorno; + } + + private void populateSelectLists() { + result.include("tipoTesteList", dao.getAllTipoTeste()); + } + +} diff --git a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/FaixaController.java b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/FaixaController.java index 015a38d..a69bc31 100644 --- a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/FaixaController.java +++ b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/FaixaController.java @@ -1,329 +1,329 @@ -package br.com.eselo.controller; - -import java.util.ArrayList; -import java.util.List; - -import br.com.caelum.vraptor.Get; -import br.com.caelum.vraptor.Path; -import br.com.caelum.vraptor.Post; -import br.com.caelum.vraptor.Put; -import br.com.caelum.vraptor.Resource; -import br.com.caelum.vraptor.Result; -import br.com.caelum.vraptor.Validator; -import br.com.caelum.vraptor.validator.ValidationMessage; -import br.com.eselo.annotations.Restrito; -import br.com.eselo.component.CopiadorParametroCalculo; -import br.com.eselo.component.Messages; -import br.com.eselo.component.UsuarioWeb; -import br.com.eselo.dao.CriterioDAO; -import br.com.eselo.dao.FaixaDAO; -import br.com.eselo.dao.ParametroCalculoDAO; -import br.com.eselo.dao.RecomendacaoDAO; -import br.com.eselo.model.Criterio; -import br.com.eselo.model.Faixa; -import br.com.eselo.model.ParametroCalculo; -import br.com.eselo.model.Recomendacao; - -@Resource -public class FaixaController { - - private final FaixaDAO dao; - private final CriterioDAO daoCriterio; - private final ParametroCalculoDAO paDAO; - private final Result result; - private final Validator validator; - private final UsuarioWeb usuarioWeb; - - public FaixaController(FaixaDAO _dao, - RecomendacaoDAO _daoRecomendacao, CriterioDAO _daoCriterio, ParametroCalculoDAO _daoParametro, - Result _result, Validator _validator, UsuarioWeb _usuarioWeb) { - this.dao = _dao; - this.daoCriterio = _daoCriterio; - this.paDAO = _daoParametro; - this.result = _result; - this.validator = _validator; - this.usuarioWeb = _usuarioWeb; - } - - public List lista(Long idCriterio) { - return this.index(idCriterio, 1); - } - - @Get("/faixas") - @Restrito(descricao = "CONFORMIDADES_LISTA") - public List index(Long idCriterio, int pagina) { - CriterioDAO cDAO = new CriterioDAO(dao.getSession()); - Criterio criterioAtual = cDAO.load(idCriterio); - - // Paginação - // Quantidade de registros por pagina - int exibi = 7; - - // Informa a quantidade de registros - int registros = dao.numLinhas(criterioAtual); - - // Quantidade de paginas na paginação - int totalPag = registros / exibi; - - // Se houver resto na divisao acima acrescenta uma pagina na paginação - if ((registros - (totalPag * exibi)) > 0) - totalPag++; - - // Calculo do registro inicial e final - int regIni = ((exibi * pagina) - exibi); - int regFim = (regIni + exibi); - - if (regFim > registros) { - regFim = registros; - } - - // Fim paginação - List resultado = dao.listAllAtivas(criterioAtual); - List paginacao = new ArrayList(); - - for (int i = regIni; i < regFim; i++) { - paginacao.add(resultado.get(i)); - } - - result.include("paginas", totalPag); - result.include("registros", registros); - result.include("regInic", ++regIni); - result.include("regFim", regFim); - result.include("controle", "diretriz"); - result.include("parametroAvaliacao", criterioAtual.getRecomendacao().getParametroCalculo()); - - return paginacao; - } - - - @Get("/faixas/gerarForm/{diretrizId}/{quantidade}") - @Restrito(descricao = "CONFORMIDADES_ADICIONAR") - public void gerarForm(Long diretrizId, int quantidade) { - result.include("quantidadeFaixas", quantidade); - result.forwardTo(this).add(diretrizId); - } - - @Get("/faixas/{criterioId}") - @Restrito(descricao = "CONFORMIDADES_ADICIONAR") - public void add(Long criterioId) { - Criterio criterio = daoCriterio.load(criterioId); - result.include("criterioId", criterioId); - result.include("criterio", criterio); - result.include("parametroCalculo", criterio.getRecomendacao().getParametroCalculo()); - populateSelectLists(); - } - - @Get("/faixas/form/{id}") - @Restrito(descricao = "CONFORMIDADES_ATUALIZAR") - public Faixa form(Long id) { - Faixa faixa = dao.load(id); - - result.include("criterioId", faixa.getCriterio().getId()); - result.include("parametroCalculo", faixa.getCriterio().getRecomendacao().getParametroCalculo()); - populateSelectLists(); - - return faixa; - } - - @Post("/faixas/add") - @Restrito(descricao = "CONFORMIDADES_ADICIONAR") - public void adicionar(List faixas) { - - Criterio criterio = daoCriterio.load(faixas.get(0).getCriterio().getId()); - - for (Faixa faixa : faixas) { - faixa.setCriterio(criterio); - //criterioId = faixa.getCriterio().getId(); - validarFaixa(faixa); - - validator.onErrorUsePageOf(FaixaController.class).add( - faixa.getCriterio().getId()); - } - - - criarNovoParametroAvaliacao(faixas, ParametroCalculoController.MODO_ADD); - - result.include("mensagem", Messages.getString("faixas.mensagem.salva")); - result.redirectTo(CriteriosController.class).form(criterio.getId()); - } - - @Put("/faixas") - @Restrito(descricao = "CONFORMIDADES_ATUALIZAR") - public void atualizar(Faixa faixa) { - Faixa faixaCadastrada = dao.load(faixa.getId()); - - Criterio criterio = daoCriterio.load(faixa.getCriterio().getId()); - - result.include("criterioId", criterio.getId()); - result.include("criterio", criterio); - result.include("parametroCalculo", criterio.getRecomendacao().getParametroCalculo()); - - faixa.setCriterio(criterio); - - validarFaixa(faixa); - - validator.onErrorRedirectTo(FaixaController.class).form(faixaCadastrada.getId()); - - if(validarAtualizacaoFaixa(faixa)){ - faixaCadastrada.setCriterio(faixa.getCriterio()); - faixaCadastrada.setFaixaInicio(faixa.getFaixaInicio()); - faixaCadastrada.setFaixaFim(faixa.getFaixaFim()); - faixaCadastrada.setDescricao(faixa.getDescricao()); - faixaCadastrada.setPercentualConformidade(faixa.getPercentualConformidade()); - - List faixas = new ArrayList(); - faixas.add(faixaCadastrada); - - criarNovoParametroAvaliacao(faixas, ParametroCalculoController.MODO_EDIT); - result.include("mensagem", Messages.getString("faixas.mensagem.alterada")); - }else{ - faixaCadastrada.setDescricao(faixa.getDescricao()); - dao.update(faixaCadastrada); - result.include("mensagem", "Nenhum campo foi alterado."); - } - - result.redirectTo(FaixaController.class).form(faixa.getId()); } - - @Path("/faixas/delete/{id}") - @Restrito(descricao = "CONFORMIDADES_EXCLUIR") - public void excluir(Long id) { - Faixa faixa = dao.load(id); - - List faixas = new ArrayList(); - faixas.add(faixa); - criarNovoParametroAvaliacao(faixas, ParametroCalculoController.MODO_DELETE); - - result.include("mensagem", "Conformidade excluída com sucesso."); - result.redirectTo(ParametroCalculoController.class).index(1); - } - - private void populateSelectLists() { - result.include("faixaList", dao.getAllRecomendacao()); - } - - private void validarFaixa(Faixa faixa) { - if (faixa.getCriterio().getId() == null) { - validator.add(new ValidationMessage(Messages - .getString("faixas.validacao.faixa"), - "faixa.diretriz.id")); - } else if (faixa.getFaixa() == null) { - validator.add(new ValidationMessage(Messages - .getString("faixas.validacao.faixa"), - "faixa.faixa")); - } else if (faixa.getDescricao() == null) { - validator.add(new ValidationMessage(Messages - .getString("faixas.validacao.descricao"), - "faixa.descricao")); - } else if (faixa.getFaixaInicio() == null) { - validator.add(new ValidationMessage(Messages - .getString("faixas.validacao.faixa_inicial"), - "faixa.faixaInicio")); - } else if (faixa.getFaixaFim() == null) { - validator.add(new ValidationMessage(Messages - .getString("faixas.validacao.faixa_final"), - "faixa.faixaFim")); - } else if (faixa.getFaixaInicio() > faixa.getFaixaFim()) { - validator.add(new ValidationMessage(Messages - .getString("faixas.validacao.range_faixas"), - "faixa.faixaInicio")); - } else if (faixa.getPercentualConformidade() == null) { - validator.add(new ValidationMessage(Messages - .getString("faixas.validacao.percentual_conformidade"), - "faixa.percentualConformidade")); - } - } - - private boolean validarAtualizacaoFaixa(Faixa faixa) { - - boolean alteracao = false; - - Faixa faixaCadastrada = dao.load(faixa.getId()); - - if (faixa.getFaixa().compareTo(faixaCadastrada.getFaixa())!=0) { - alteracao = true; - } else if (faixa.getDescricao().compareToIgnoreCase(faixaCadastrada.getDescricao()) != 0) { - alteracao = true; - } else if (faixa.getFaixaInicio().compareTo(faixaCadastrada.getFaixaInicio())!=0) { - alteracao = true; - } else if (faixa.getFaixaFim().compareTo(faixaCadastrada.getFaixaFim()) !=0) { - alteracao = true; - } else if (faixa.getPercentualConformidade().compareTo(faixaCadastrada.getPercentualConformidade()) !=0) { - alteracao = true; - } - - return alteracao; - } - - private void criarNovoParametroAvaliacao(List faixas, int tipo) { - ParametroCalculo ultimoParametroAvaliacao = paDAO.getLastParametrosCalculo(); - boolean ok = false; - Faixa faixa; - - switch (tipo) { - case ParametroCalculoController.MODO_ADD: - for(Faixa f:faixas){ - for(Recomendacao recomendacao: ultimoParametroAvaliacao.getRecomendacoes()){ - if(recomendacao.getId().longValue()==f.getCriterio().getRecomendacao().getId().longValue()){ - for(Criterio criterio: recomendacao.getCriterios()){ - if(criterio.getId().longValue()==f.getCriterio().getId().longValue()){ - criterio.addFaixa(f); - ok=true; - break; - - } - } - } - } - } - - break; - - case ParametroCalculoController.MODO_EDIT: - faixa = faixas.get(0); - for(Recomendacao recomendacao: ultimoParametroAvaliacao.getRecomendacoes()){ - if(recomendacao.getId().longValue()==faixa.getCriterio().getRecomendacao().getId().longValue()){ - for(Criterio criterio: recomendacao.getCriterios()){ - if(criterio.getId().longValue()==faixa.getCriterio().getId().longValue()){ - for(Faixa f: criterio.getFaixas()){ - if(f.getId().longValue()==faixa.getId().longValue()){ - f.setCriterio(faixa.getCriterio()); - f.setDescricao(faixa.getDescricao()); - f.setFaixa(faixa.getFaixa()); - f.setFaixaFim(faixa.getFaixaFim()); - f.setFaixaInicio(faixa.getFaixaInicio()); - f.setId(faixa.getId()); - f.setPercentualConformidade(faixa.getPercentualConformidade()); - ok=true; - } - } - } - } - } - } - - break; - - case ParametroCalculoController.MODO_DELETE: - faixa = faixas.get(0); - for(Recomendacao recomendacao: ultimoParametroAvaliacao.getRecomendacoes()){ - if(recomendacao.getId().longValue()==faixa.getCriterio().getRecomendacao().getId().longValue()){ - for(Criterio criterio: recomendacao.getCriterios()){ - if(criterio.getId().longValue()==faixa.getCriterio().getId().longValue()){ - criterio.removeFaixa(faixa); - ok=true; - break; - - } - } - } - } - - break; - } - - if(ok){ - new CopiadorParametroCalculo().criarNovoParametroCalculo(ultimoParametroAvaliacao, usuarioWeb, dao.getSession()); - } - } - -} +package br.com.eselo.controller; + +import java.util.ArrayList; +import java.util.List; + +import br.com.caelum.vraptor.Get; +import br.com.caelum.vraptor.Path; +import br.com.caelum.vraptor.Post; +import br.com.caelum.vraptor.Put; +import br.com.caelum.vraptor.Resource; +import br.com.caelum.vraptor.Result; +import br.com.caelum.vraptor.Validator; +import br.com.caelum.vraptor.validator.ValidationMessage; +import br.com.eselo.annotations.Restrito; +import br.com.eselo.component.CopiadorParametroCalculo; +import br.com.eselo.component.Messages; +import br.com.eselo.component.UsuarioWeb; +import br.com.eselo.dao.CriterioDAO; +import br.com.eselo.dao.FaixaDAO; +import br.com.eselo.dao.ParametroCalculoDAO; +import br.com.eselo.dao.RecomendacaoDAO; +import br.com.eselo.model.Criterio; +import br.com.eselo.model.Faixa; +import br.com.eselo.model.ParametroCalculo; +import br.com.eselo.model.Recomendacao; + +@Resource +public class FaixaController { + + private final FaixaDAO dao; + private final CriterioDAO daoCriterio; + private final ParametroCalculoDAO paDAO; + private final Result result; + private final Validator validator; + private final UsuarioWeb usuarioWeb; + + public FaixaController(FaixaDAO _dao, + RecomendacaoDAO _daoRecomendacao, CriterioDAO _daoCriterio, ParametroCalculoDAO _daoParametro, + Result _result, Validator _validator, UsuarioWeb _usuarioWeb) { + this.dao = _dao; + this.daoCriterio = _daoCriterio; + this.paDAO = _daoParametro; + this.result = _result; + this.validator = _validator; + this.usuarioWeb = _usuarioWeb; + } + + public List lista(Long idCriterio) { + return this.index(idCriterio, 1); + } + + @Get("/faixas") + @Restrito(descricao = "CONFORMIDADES_LISTA") + public List index(Long idCriterio, int pagina) { + CriterioDAO cDAO = new CriterioDAO(dao.getSession()); + Criterio criterioAtual = cDAO.load(idCriterio); + + // Paginação + // Quantidade de registros por pagina + int exibi = 7; + + // Informa a quantidade de registros + int registros = dao.numLinhas(criterioAtual); + + // Quantidade de paginas na paginação + int totalPag = registros / exibi; + + // Se houver resto na divisao acima acrescenta uma pagina na paginação + if ((registros - (totalPag * exibi)) > 0) + totalPag++; + + // Calculo do registro inicial e final + int regIni = ((exibi * pagina) - exibi); + int regFim = (regIni + exibi); + + if (regFim > registros) { + regFim = registros; + } + + // Fim paginação + List resultado = dao.listAllAtivas(criterioAtual); + List paginacao = new ArrayList(); + + for (int i = regIni; i < regFim; i++) { + paginacao.add(resultado.get(i)); + } + + result.include("paginas", totalPag); + result.include("registros", registros); + result.include("regInic", ++regIni); + result.include("regFim", regFim); + result.include("controle", "diretriz"); + result.include("parametroAvaliacao", criterioAtual.getRecomendacao().getParametroCalculo()); + + return paginacao; + } + + + @Get("/faixas/gerarForm/{diretrizId}/{quantidade}") + @Restrito(descricao = "CONFORMIDADES_ADICIONAR") + public void gerarForm(Long diretrizId, int quantidade) { + result.include("quantidadeFaixas", quantidade); + result.forwardTo(this).add(diretrizId); + } + + @Get("/faixas/{criterioId}") + @Restrito(descricao = "CONFORMIDADES_ADICIONAR") + public void add(Long criterioId) { + Criterio criterio = daoCriterio.load(criterioId); + result.include("criterioId", criterioId); + result.include("criterio", criterio); + result.include("parametroCalculo", criterio.getRecomendacao().getParametroCalculo()); + populateSelectLists(); + } + + @Get("/faixas/form/{id}") + @Restrito(descricao = "CONFORMIDADES_ATUALIZAR") + public Faixa form(Long id) { + Faixa faixa = dao.load(id); + + result.include("criterioId", faixa.getCriterio().getId()); + result.include("parametroCalculo", faixa.getCriterio().getRecomendacao().getParametroCalculo()); + populateSelectLists(); + + return faixa; + } + + @Post("/faixas/add") + @Restrito(descricao = "CONFORMIDADES_ADICIONAR") + public void adicionar(List faixas) { + + Criterio criterio = daoCriterio.load(faixas.get(0).getCriterio().getId()); + + for (Faixa faixa : faixas) { + faixa.setCriterio(criterio); + //criterioId = faixa.getCriterio().getId(); + validarFaixa(faixa); + + validator.onErrorUsePageOf(FaixaController.class).add( + faixa.getCriterio().getId()); + } + + + criarNovoParametroAvaliacao(faixas, ParametroCalculoController.MODO_ADD); + + result.include("mensagem", Messages.getString("faixas.mensagem.salva")); + result.redirectTo(CriteriosController.class).form(criterio.getId()); + } + + @Put("/faixas") + @Restrito(descricao = "CONFORMIDADES_ATUALIZAR") + public void atualizar(Faixa faixa) { + Faixa faixaCadastrada = dao.load(faixa.getId()); + + Criterio criterio = daoCriterio.load(faixa.getCriterio().getId()); + + result.include("criterioId", criterio.getId()); + result.include("criterio", criterio); + result.include("parametroCalculo", criterio.getRecomendacao().getParametroCalculo()); + + faixa.setCriterio(criterio); + + validarFaixa(faixa); + + validator.onErrorRedirectTo(FaixaController.class).form(faixaCadastrada.getId()); + + if(validarAtualizacaoFaixa(faixa)){ + faixaCadastrada.setCriterio(faixa.getCriterio()); + faixaCadastrada.setFaixaInicio(faixa.getFaixaInicio()); + faixaCadastrada.setFaixaFim(faixa.getFaixaFim()); + faixaCadastrada.setDescricao(faixa.getDescricao()); + faixaCadastrada.setPercentualConformidade(faixa.getPercentualConformidade()); + + List faixas = new ArrayList(); + faixas.add(faixaCadastrada); + + criarNovoParametroAvaliacao(faixas, ParametroCalculoController.MODO_EDIT); + result.include("mensagem", Messages.getString("faixas.mensagem.alterada")); + }else{ + faixaCadastrada.setDescricao(faixa.getDescricao()); + dao.update(faixaCadastrada); + result.include("mensagem", "Nenhum campo foi alterado."); + } + + result.redirectTo(FaixaController.class).form(faixa.getId()); } + + @Path("/faixas/delete/{id}") + @Restrito(descricao = "CONFORMIDADES_EXCLUIR") + public void excluir(Long id) { + Faixa faixa = dao.load(id); + + List faixas = new ArrayList(); + faixas.add(faixa); + criarNovoParametroAvaliacao(faixas, ParametroCalculoController.MODO_DELETE); + + result.include("mensagem", "Conformidade excluída com sucesso."); + result.redirectTo(ParametroCalculoController.class).index(1); + } + + private void populateSelectLists() { + result.include("faixaList", dao.getAllRecomendacao()); + } + + private void validarFaixa(Faixa faixa) { + if (faixa.getCriterio().getId() == null) { + validator.add(new ValidationMessage(Messages + .getString("faixas.validacao.faixa"), + "faixa.diretriz.id")); + } else if (faixa.getFaixa() == null) { + validator.add(new ValidationMessage(Messages + .getString("faixas.validacao.faixa"), + "faixa.faixa")); + } else if (faixa.getDescricao() == null) { + validator.add(new ValidationMessage(Messages + .getString("faixas.validacao.descricao"), + "faixa.descricao")); + } else if (faixa.getFaixaInicio() == null) { + validator.add(new ValidationMessage(Messages + .getString("faixas.validacao.faixa_inicial"), + "faixa.faixaInicio")); + } else if (faixa.getFaixaFim() == null) { + validator.add(new ValidationMessage(Messages + .getString("faixas.validacao.faixa_final"), + "faixa.faixaFim")); + } else if (faixa.getFaixaInicio() > faixa.getFaixaFim()) { + validator.add(new ValidationMessage(Messages + .getString("faixas.validacao.range_faixas"), + "faixa.faixaInicio")); + } else if (faixa.getPercentualConformidade() == null) { + validator.add(new ValidationMessage(Messages + .getString("faixas.validacao.percentual_conformidade"), + "faixa.percentualConformidade")); + } + } + + private boolean validarAtualizacaoFaixa(Faixa faixa) { + + boolean alteracao = false; + + Faixa faixaCadastrada = dao.load(faixa.getId()); + + if (faixa.getFaixa().compareTo(faixaCadastrada.getFaixa())!=0) { + alteracao = true; + } else if (faixa.getDescricao().compareToIgnoreCase(faixaCadastrada.getDescricao()) != 0) { + alteracao = true; + } else if (faixa.getFaixaInicio().compareTo(faixaCadastrada.getFaixaInicio())!=0) { + alteracao = true; + } else if (faixa.getFaixaFim().compareTo(faixaCadastrada.getFaixaFim()) !=0) { + alteracao = true; + } else if (faixa.getPercentualConformidade().compareTo(faixaCadastrada.getPercentualConformidade()) !=0) { + alteracao = true; + } + + return alteracao; + } + + private void criarNovoParametroAvaliacao(List faixas, int tipo) { + ParametroCalculo ultimoParametroAvaliacao = paDAO.getLastParametrosCalculo(); + boolean ok = false; + Faixa faixa; + + switch (tipo) { + case ParametroCalculoController.MODO_ADD: + for(Faixa f:faixas){ + for(Recomendacao recomendacao: ultimoParametroAvaliacao.getRecomendacoes()){ + if(recomendacao.getId().longValue()==f.getCriterio().getRecomendacao().getId().longValue()){ + for(Criterio criterio: recomendacao.getCriterios()){ + if(criterio.getId().longValue()==f.getCriterio().getId().longValue()){ + criterio.addFaixa(f); + ok=true; + break; + + } + } + } + } + } + + break; + + case ParametroCalculoController.MODO_EDIT: + faixa = faixas.get(0); + for(Recomendacao recomendacao: ultimoParametroAvaliacao.getRecomendacoes()){ + if(recomendacao.getId().longValue()==faixa.getCriterio().getRecomendacao().getId().longValue()){ + for(Criterio criterio: recomendacao.getCriterios()){ + if(criterio.getId().longValue()==faixa.getCriterio().getId().longValue()){ + for(Faixa f: criterio.getFaixas()){ + if(f.getId().longValue()==faixa.getId().longValue()){ + f.setCriterio(faixa.getCriterio()); + f.setDescricao(faixa.getDescricao()); + f.setFaixa(faixa.getFaixa()); + f.setFaixaFim(faixa.getFaixaFim()); + f.setFaixaInicio(faixa.getFaixaInicio()); + f.setId(faixa.getId()); + f.setPercentualConformidade(faixa.getPercentualConformidade()); + ok=true; + } + } + } + } + } + } + + break; + + case ParametroCalculoController.MODO_DELETE: + faixa = faixas.get(0); + for(Recomendacao recomendacao: ultimoParametroAvaliacao.getRecomendacoes()){ + if(recomendacao.getId().longValue()==faixa.getCriterio().getRecomendacao().getId().longValue()){ + for(Criterio criterio: recomendacao.getCriterios()){ + if(criterio.getId().longValue()==faixa.getCriterio().getId().longValue()){ + criterio.removeFaixa(faixa); + ok=true; + break; + + } + } + } + } + + break; + } + + if(ok){ + new CopiadorParametroCalculo().criarNovoParametroCalculo(ultimoParametroAvaliacao, usuarioWeb, dao.getSession()); + } + } + +} diff --git a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/GruposController.java b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/GruposController.java index 499e524..2c36447 100644 --- a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/GruposController.java +++ b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/GruposController.java @@ -1,128 +1,128 @@ -package br.com.eselo.controller; - -import java.util.List; - -import br.com.caelum.vraptor.Get; -import br.com.caelum.vraptor.Path; -import br.com.caelum.vraptor.Post; -import br.com.caelum.vraptor.Put; -import br.com.caelum.vraptor.Resource; -import br.com.caelum.vraptor.Result; -import br.com.caelum.vraptor.Validator; -import br.com.caelum.vraptor.validator.ValidationMessage; -import br.com.eselo.annotations.Restrito; -import br.com.eselo.dao.GrupoDAO; -import br.com.eselo.model.Grupo; - -@Resource -public class GruposController { - - private final GrupoDAO dao; - private final Result result; - private final Validator validator; - - public GruposController(GrupoDAO _dao, Result _result, Validator _validator) { - dao = _dao; - result = _result; - validator = _validator; - } - - @Get("/grupos/lista") - @Restrito(descricao = "GRUPOS_LISTA") - public List lista(Grupo grupo) { - result.include("usuario", grupo); - return dao.listAll(grupo); - } - - @Get("/grupos") - @Restrito(descricao = "GRUPOS_LISTA") - public List lista() { - return dao.listAll(); - } - - @Restrito(descricao = "GRUPOS_ADICIONAR") - public void form() { - if (!result.included().containsKey("permissaoList")) { - result.include("permissaoList", dao.getAllPermissoes()); - } - } - - @Get("/grupos/{id}") - @Restrito(descricao = "GRUPOS_ATUALIZAR") - public Grupo form(Long id) { - Grupo grupo = this.dao.load(id); - getPermissaoList(grupo); - return grupo; - } - - @Post("/grupos") - @Restrito(descricao = "GRUPOS_ADICIONAR") - public void adicionar(Grupo grupo) { - getPermissaoList(grupo); - validate(grupo); - - dao.save(grupo); - - result.include("mensagem", "Grupo salvo com sucesso."); - result.redirectTo(GruposController.class).lista(); - } - - @Put("/grupos") - @Restrito(descricao = "GRUPOS_ATUALIZAR") - public void atualizar(Grupo grupo) { - getPermissaoList(grupo); - validate(grupo); - - Grupo grupoCadastrado = dao.load(grupo.getId()); - grupoCadastrado.setNome(grupo.getNome()); - grupoCadastrado.setPermissoes(grupo.getPermissoes()); - - dao.saveOrUpdate(grupoCadastrado); - - result.include("mensagem", "Grupo alterado com sucesso."); - result.redirectTo(GruposController.class).lista(); - } - - @Path("/grupos/delete/{id}") - @Restrito(descricao = "GRUPOS_EXCLUIR") - public void excluir(Long id) { - Grupo grupo = dao.load(id); - - if (!grupo.getUsuarios().isEmpty()) { - validator.add(new ValidationMessage( - "O grupo está sendo referenciado e não pode ser excluído.", - "grupo.nome")); - } - validator.onErrorForwardTo(GruposController.class).lista(); - - dao.remove(id); - - result.include("mensagem", "Grupo excluído com sucesso."); - result.redirectTo(GruposController.class).lista(); - } - - private void getPermissaoList(Grupo grupo) { - if (grupo.getPermissoes() != null) { - result.include("permissaoList", - dao.getAllPermissoes(grupo.getPermissoes())); - } else { - result.include("permissaoList", dao.getAllPermissoes()); - } - } - - private void validate(Grupo grupo) { - Long idGrupoMesmoNome = dao.getIdByNome(grupo.getNome(), grupo.getId()); - - if (grupo.getNome() == null) { - validator.add(new ValidationMessage( - "O nome do grupo é obrigatório.", "grupo.nome")); - } else if (idGrupoMesmoNome != null) { - validator.add(new ValidationMessage( - "O grupo não pode ser igual a um já existente.", - "grupo.nome")); - } - - validator.onErrorUsePageOf(GruposController.class).form(); - } - -} +package br.com.eselo.controller; + +import java.util.List; + +import br.com.caelum.vraptor.Get; +import br.com.caelum.vraptor.Path; +import br.com.caelum.vraptor.Post; +import br.com.caelum.vraptor.Put; +import br.com.caelum.vraptor.Resource; +import br.com.caelum.vraptor.Result; +import br.com.caelum.vraptor.Validator; +import br.com.caelum.vraptor.validator.ValidationMessage; +import br.com.eselo.annotations.Restrito; +import br.com.eselo.dao.GrupoDAO; +import br.com.eselo.model.Grupo; + +@Resource +public class GruposController { + + private final GrupoDAO dao; + private final Result result; + private final Validator validator; + + public GruposController(GrupoDAO _dao, Result _result, Validator _validator) { + dao = _dao; + result = _result; + validator = _validator; + } + + @Get("/grupos/lista") + @Restrito(descricao = "GRUPOS_LISTA") + public List lista(Grupo grupo) { + result.include("usuario", grupo); + return dao.listAll(grupo); + } + + @Get("/grupos") + @Restrito(descricao = "GRUPOS_LISTA") + public List lista() { + return dao.listAll(); + } + + @Restrito(descricao = "GRUPOS_ADICIONAR") + public void form() { + if (!result.included().containsKey("permissaoList")) { + result.include("permissaoList", dao.getAllPermissoes()); + } + } + + @Get("/grupos/{id}") + @Restrito(descricao = "GRUPOS_ATUALIZAR") + public Grupo form(Long id) { + Grupo grupo = this.dao.load(id); + getPermissaoList(grupo); + return grupo; + } + + @Post("/grupos") + @Restrito(descricao = "GRUPOS_ADICIONAR") + public void adicionar(Grupo grupo) { + getPermissaoList(grupo); + validate(grupo); + + dao.save(grupo); + + result.include("mensagem", "Grupo salvo com sucesso."); + result.redirectTo(GruposController.class).lista(); + } + + @Put("/grupos") + @Restrito(descricao = "GRUPOS_ATUALIZAR") + public void atualizar(Grupo grupo) { + getPermissaoList(grupo); + validate(grupo); + + Grupo grupoCadastrado = dao.load(grupo.getId()); + grupoCadastrado.setNome(grupo.getNome()); + grupoCadastrado.setPermissoes(grupo.getPermissoes()); + + dao.saveOrUpdate(grupoCadastrado); + + result.include("mensagem", "Grupo alterado com sucesso."); + result.redirectTo(GruposController.class).lista(); + } + + @Path("/grupos/delete/{id}") + @Restrito(descricao = "GRUPOS_EXCLUIR") + public void excluir(Long id) { + Grupo grupo = dao.load(id); + + if (!grupo.getUsuarios().isEmpty()) { + validator.add(new ValidationMessage( + "O grupo está sendo referenciado e não pode ser excluído.", + "grupo.nome")); + } + validator.onErrorForwardTo(GruposController.class).lista(); + + dao.remove(id); + + result.include("mensagem", "Grupo excluído com sucesso."); + result.redirectTo(GruposController.class).lista(); + } + + private void getPermissaoList(Grupo grupo) { + if (grupo.getPermissoes() != null) { + result.include("permissaoList", + dao.getAllPermissoes(grupo.getPermissoes())); + } else { + result.include("permissaoList", dao.getAllPermissoes()); + } + } + + private void validate(Grupo grupo) { + Long idGrupoMesmoNome = dao.getIdByNome(grupo.getNome(), grupo.getId()); + + if (grupo.getNome() == null) { + validator.add(new ValidationMessage( + "O nome do grupo é obrigatório.", "grupo.nome")); + } else if (idGrupoMesmoNome != null) { + validator.add(new ValidationMessage( + "O grupo não pode ser igual a um já existente.", + "grupo.nome")); + } + + validator.onErrorUsePageOf(GruposController.class).form(); + } + +} diff --git a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/PainelController.java b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/PainelController.java index d9e262e..b427ce0 100644 --- a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/PainelController.java +++ b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/PainelController.java @@ -1,16 +1,16 @@ -package br.com.eselo.controller; - -import br.com.caelum.vraptor.Get; -import br.com.caelum.vraptor.Resource; -import br.com.eselo.annotations.Restrito; - -@Resource -public class PainelController { - - @Restrito(descricao = "PAINEL") - @Get("/painel") - public void index() { - - } - -} +package br.com.eselo.controller; + +import br.com.caelum.vraptor.Get; +import br.com.caelum.vraptor.Resource; +import br.com.eselo.annotations.Restrito; + +@Resource +public class PainelController { + + @Restrito(descricao = "PAINEL") + @Get("/painel") + public void index() { + + } + +} diff --git a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/ParametroCalculoController.java b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/ParametroCalculoController.java index 7405e70..19402a7 100644 --- a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/ParametroCalculoController.java +++ b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/ParametroCalculoController.java @@ -78,30 +78,30 @@ public class ParametroCalculoController { @Get("/parametrosCalculo/importar/") @Restrito(descricao = "PARAMETRO_CALCULO_ADICIONAR") public void importar(long idParametroCalculo) { - + String acao = VRaptorRequestHolder.currentRequest().getRequest().getParameter("acao"); - + String mensagem=""; - + if(acao.equals("Importar")){ ParametroCalculo pc = dao.load(idParametroCalculo); this.criarNovoParametroCalculo(pc, MODO_IMPORT); mensagem = "Parâmetro de Cálculo criado com base no parametro " + pc.getDescricao() + " com sucesso."; - + result.redirectTo(ParametroCalculoController.class).form(dao.getMaxId()); }else if(acao.equals("Não Importar")){ criarNovoParametroCalculo(new ParametroCalculo(), MODO_ADD); mensagem = "Novo parâmetro criado [sem recomendações ou critérios associados]!"; - + result.redirectTo(ParametroCalculoController.class).form(dao.getMaxId()); }else if(acao.equals("Cancelar")){ mensagem = "Ação cancelada!"; result.redirectTo(ParametroCalculoController.class).lista(); } - + result.include("mensagem", mensagem); } @@ -154,7 +154,7 @@ public class ParametroCalculoController { List usuarios = dao.getAllUsuarios(); ParametroCalculo parametroCalculoCadastrado = dao.load(parametroCalculo.getId()); - + parametroCalculo.setTsInicio(parametroCalculoCadastrado.getTsInicio()); parametroCalculoCadastrado.setUsuario(new UsuarioDAO(dao.getSession()).load(usuarioWeb.getId())); parametroCalculo.setUsuario(parametroCalculoCadastrado.getUsuario()); @@ -174,13 +174,13 @@ public class ParametroCalculoController { "parametroCalculo.descricao")); } - - + + result.include("usuarioList", usuarios); result.include("recomendacaoList", parametroCalculoCadastrado.getRecomendacoes()); result.include("parametroCalculo", parametroCalculoCadastrado); - - + + validator.onErrorUsePageOf(ParametroCalculoController.class).form(parametroCalculo.getId()); dao.saveOrUpdate(parametroCalculoCadastrado); diff --git a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/PermissoesController.java b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/PermissoesController.java index b8bdbc4..d07ca6e 100644 --- a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/PermissoesController.java +++ b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/PermissoesController.java @@ -1,121 +1,121 @@ -package br.com.eselo.controller; - -import java.util.List; - -import br.com.caelum.vraptor.Get; -import br.com.caelum.vraptor.Path; -import br.com.caelum.vraptor.Post; -import br.com.caelum.vraptor.Put; -import br.com.caelum.vraptor.Resource; -import br.com.caelum.vraptor.Result; -import br.com.caelum.vraptor.Validator; -import br.com.caelum.vraptor.validator.ValidationMessage; -import br.com.eselo.annotations.Restrito; -import br.com.eselo.dao.PermissaoDAO; -import br.com.eselo.model.Permissao; - -@Resource -public class PermissoesController { - - private final PermissaoDAO dao; - private final Result result; - private final Validator validator; - - public PermissoesController(PermissaoDAO _dao, Result _result, - Validator _validator) { - dao = _dao; - result = _result; - validator = _validator; - } - - @Get("/permissoes") - @Restrito(descricao = "PERMISSOES_LISTA") - public List lista() { - return dao.listAll(); - } - - @Restrito(descricao = "") - public void form() { - - } - - @Get("/permissoes/{id}") - @Restrito(descricao = "") - public Permissao form(Long id) { - Permissao permissao = dao.load(id); - return permissao; - } - - @Post("/permissoes") - @Restrito(descricao = "") - public void adicionar(Permissao permissao) { - Long idPermissaoMesmoCpf = dao.getIdByDescricao(permissao.getPermissao()); - - if (permissao.getPermissao() == null) { - validator.add(new ValidationMessage("A descrição da permissão é obrigatória.", - "permissao.permissao")); - } else if (idPermissaoMesmoCpf != null) { - validator.add(new ValidationMessage( - "A permissão não pode ser igual a uma já existente.", - "permissao.permissao")); - } - validator.onErrorUsePageOf(PermissoesController.class).form(); - - dao.save(permissao); - - result.include("mensagem", "Permissão salva com sucesso."); - result.redirectTo(PermissoesController.class).lista(); - } - - @Put("/permissoes") - @Restrito(descricao = "") - public void atualizar(Permissao permissao) { - Permissao permissaoCadastrada = dao.load(permissao.getId()); - permissaoCadastrada.setPermissao(permissao.getPermissao()); - - Long idPermissaoMesmaDescricao = dao.getIdByDescricao(permissaoCadastrada.getPermissao()); - - if (permissaoCadastrada.getPermissao() == null) { - validator.add(new ValidationMessage("A descrição da permissão é obrigatória.", - "permissao.permissao")); - } else if (idPermissaoMesmaDescricao != null - && !idPermissaoMesmaDescricao.equals(permissaoCadastrada.getId())) { - validator.add(new ValidationMessage( - "A permissão não pode ser igual a uma já existente.", - "permissao.permissao")); - } - validator.onErrorUsePageOf(PermissoesController.class).form(); - - dao.saveOrUpdate(permissaoCadastrada); - - result.include("mensagem", "Permissão alterada com sucesso."); - result.redirectTo(PermissoesController.class).lista(); - } - - @Path("/permissoes/delete/{id}") - @Restrito(descricao = "") - public void excluir(Long id) { - Permissao permissaoCadastrada = dao.load(id); - - if (!permissaoCadastrada.getGrupos().isEmpty()) { - validator.add(new ValidationMessage("A permissão está sendo referenciada e não pode ser excluída.", - "permissao.permissao")); - } - validator.onErrorForwardTo(PermissoesController.class).lista(); - - dao.remove(id); - - result.include("mensagem", "Permissão excluída com sucesso."); - result.redirectTo(PermissoesController.class).lista(); - } - - @Get("/permissoes/sincronizar") - @Restrito(descricao = "PERMISSOES_SINCRONIZAR") - public void sincronizar() { - dao.sincronizar(); - - result.include("mensagem", "Permissões sincronizadas com sucesso."); - result.redirectTo(PermissoesController.class).lista(); - } - -} +package br.com.eselo.controller; + +import java.util.List; + +import br.com.caelum.vraptor.Get; +import br.com.caelum.vraptor.Path; +import br.com.caelum.vraptor.Post; +import br.com.caelum.vraptor.Put; +import br.com.caelum.vraptor.Resource; +import br.com.caelum.vraptor.Result; +import br.com.caelum.vraptor.Validator; +import br.com.caelum.vraptor.validator.ValidationMessage; +import br.com.eselo.annotations.Restrito; +import br.com.eselo.dao.PermissaoDAO; +import br.com.eselo.model.Permissao; + +@Resource +public class PermissoesController { + + private final PermissaoDAO dao; + private final Result result; + private final Validator validator; + + public PermissoesController(PermissaoDAO _dao, Result _result, + Validator _validator) { + dao = _dao; + result = _result; + validator = _validator; + } + + @Get("/permissoes") + @Restrito(descricao = "PERMISSOES_LISTA") + public List lista() { + return dao.listAll(); + } + + @Restrito(descricao = "") + public void form() { + + } + + @Get("/permissoes/{id}") + @Restrito(descricao = "") + public Permissao form(Long id) { + Permissao permissao = dao.load(id); + return permissao; + } + + @Post("/permissoes") + @Restrito(descricao = "") + public void adicionar(Permissao permissao) { + Long idPermissaoMesmoCpf = dao.getIdByDescricao(permissao.getPermissao()); + + if (permissao.getPermissao() == null) { + validator.add(new ValidationMessage("A descrição da permissão é obrigatória.", + "permissao.permissao")); + } else if (idPermissaoMesmoCpf != null) { + validator.add(new ValidationMessage( + "A permissão não pode ser igual a uma já existente.", + "permissao.permissao")); + } + validator.onErrorUsePageOf(PermissoesController.class).form(); + + dao.save(permissao); + + result.include("mensagem", "Permissão salva com sucesso."); + result.redirectTo(PermissoesController.class).lista(); + } + + @Put("/permissoes") + @Restrito(descricao = "") + public void atualizar(Permissao permissao) { + Permissao permissaoCadastrada = dao.load(permissao.getId()); + permissaoCadastrada.setPermissao(permissao.getPermissao()); + + Long idPermissaoMesmaDescricao = dao.getIdByDescricao(permissaoCadastrada.getPermissao()); + + if (permissaoCadastrada.getPermissao() == null) { + validator.add(new ValidationMessage("A descrição da permissão é obrigatória.", + "permissao.permissao")); + } else if (idPermissaoMesmaDescricao != null + && !idPermissaoMesmaDescricao.equals(permissaoCadastrada.getId())) { + validator.add(new ValidationMessage( + "A permissão não pode ser igual a uma já existente.", + "permissao.permissao")); + } + validator.onErrorUsePageOf(PermissoesController.class).form(); + + dao.saveOrUpdate(permissaoCadastrada); + + result.include("mensagem", "Permissão alterada com sucesso."); + result.redirectTo(PermissoesController.class).lista(); + } + + @Path("/permissoes/delete/{id}") + @Restrito(descricao = "") + public void excluir(Long id) { + Permissao permissaoCadastrada = dao.load(id); + + if (!permissaoCadastrada.getGrupos().isEmpty()) { + validator.add(new ValidationMessage("A permissão está sendo referenciada e não pode ser excluída.", + "permissao.permissao")); + } + validator.onErrorForwardTo(PermissoesController.class).lista(); + + dao.remove(id); + + result.include("mensagem", "Permissão excluída com sucesso."); + result.redirectTo(PermissoesController.class).lista(); + } + + @Get("/permissoes/sincronizar") + @Restrito(descricao = "PERMISSOES_SINCRONIZAR") + public void sincronizar() { + dao.sincronizar(); + + result.include("mensagem", "Permissões sincronizadas com sucesso."); + result.redirectTo(PermissoesController.class).lista(); + } + +} diff --git a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/RecomendacaoController.java b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/RecomendacaoController.java index acf9052..c930967 100644 --- a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/RecomendacaoController.java +++ b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/RecomendacaoController.java @@ -74,7 +74,7 @@ public class RecomendacaoController { this.criarNovoParametroAvaliacao(recomendacao, ParametroCalculoController.MODO_ADD); - result.include("mensagem", "Recomenda��o salva com sucesso."); + result.include("mensagem", "Recomenda��o salva com sucesso."); result.redirectTo(ParametroCalculoController.class).index(1); } @@ -90,13 +90,13 @@ public class RecomendacaoController { if(validarAtualizacaoRecomendacao(recomendacao)){ criarNovoParametroAvaliacao(recomendacao,ParametroCalculoController.MODO_EDIT); - result.include("mensagem", "Recomendação salva com sucesso."); + result.include("mensagem", "Recomendação salva com sucesso."); }else{ recomendacaoCadastrada.setDescricao(recomendacao.getDescricao()); dao.update(recomendacaoCadastrada); result.include("mensagem", "Nenhum campo foi alterado."); } - + result.redirectTo(RecomendacaoController.class).form(recomendacao.getId()); } @@ -108,7 +108,7 @@ public class RecomendacaoController { criarNovoParametroAvaliacao(recomendacao, ParametroCalculoController.MODO_DELETE); - result.include("mensagem", "Recomenda��o exclu�da com sucesso."); + result.include("mensagem", "Recomenda��o exclu�da com sucesso."); result.redirectTo(ParametroCalculoController.class).index(1); } @@ -162,24 +162,24 @@ public class RecomendacaoController { if (recomendacao.getNumeroRecomendacao() == null) { validator.add(new ValidationMessage( - "� obrigat�rio informar o n�mero da recomenda��o.", + "� obrigat�rio informar o n�mero da recomenda��o.", "recomendacao.numeroRecomendacao")); } else if (hasNumeroRecomendacaoNoParametroAtual(recomendacao)) { validator .add(new ValidationMessage( - "J� existe uma recomenda��o ativa com esse numero. Recomenda��o n�o atualizada.", + "J� existe uma recomenda��o ativa com esse numero. Recomenda��o n�o atualizada.", "recomendacao.numeroRecomendacao")); } else if (recomendacao.getDescricao() == null) { validator.add(new ValidationMessage( - "� obrigat�rio informar a descri��o da recomenda��o.", + "� obrigat�rio informar a descri��o da recomenda��o.", "recomendacao.descricao")); } else if (recomendacao.getPeso() == null) { validator.add(new ValidationMessage( - "� obrigat�rio informar o peso da recomenda��o.", + "� obrigat�rio informar o peso da recomenda��o.", "recomendacao.peso")); } else if (recomendacao.getPeso() <= 0) { validator.add(new ValidationMessage( - "O peso da recomenda��o deve ser maior que zero.", + "O peso da recomenda��o deve ser maior que zero.", "recomendacao.peso")); } @@ -192,9 +192,9 @@ public class RecomendacaoController { private boolean validarAtualizacaoRecomendacao(Recomendacao recomendacao) { boolean alteracao = false; - + Recomendacao recomendacaoCadastrada = dao.load(recomendacao.getId()); - + if (recomendacao.getNumeroRecomendacao().compareTo(recomendacaoCadastrada.getNumeroRecomendacao())!=0) { alteracao = true; } else if (recomendacao.getPeso().compareTo(recomendacaoCadastrada.getPeso()) !=0) { @@ -202,13 +202,13 @@ public class RecomendacaoController { } else if (recomendacao.getDescricao().compareToIgnoreCase(recomendacaoCadastrada.getDescricao()) != 0) { alteracao = true; } - + return alteracao; } /** - * Recebe uma recomenda��o antes de ser cadastrada e verifica se ja existe - * uma recomenda��o ativa com o mesmo numero. - * + * Recebe uma recomenda��o antes de ser cadastrada e verifica se ja existe + * uma recomenda��o ativa com o mesmo numero. + * * @param recomendacao * @return boolean */ diff --git a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/TestesController.java b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/TestesController.java index 9420780..e6daebc 100644 --- a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/TestesController.java +++ b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/TestesController.java @@ -1,44 +1,44 @@ -package br.com.eselo.controller; - -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import br.com.caelum.vraptor.Get; -import br.com.caelum.vraptor.Post; -import br.com.caelum.vraptor.Resource; -import br.com.caelum.vraptor.Result; -import br.com.eselo.component.LeitorXML; -import br.com.eselo.integracao.RelatorioAvaliacao; -import br.com.eselo.model.Teste; - -@Resource -public class TestesController { - - private final Result result; - private final AvaliacaoController avaliacaoController; - - private static final Logger LOGGER = LoggerFactory - .getLogger(TestesController.class); - - public TestesController(Result _result, AvaliacaoController _avaliacaoController) { - this.result = _result; - this.avaliacaoController = _avaliacaoController; - } - - @Get("/teste") - public void form() { - } - - @Post("/teste/form") - public void form(Teste teste) { - LOGGER.debug("XML: " + teste.getXml()); - - RelatorioAvaliacao relatorioAvaliacao = new LeitorXML() - .lerAvaliacaoXML(teste.getXml()); - - avaliacaoController.calcularNota(relatorioAvaliacao); - - result.include("mensagem", "Teste realizado."); - } - -} +package br.com.eselo.controller; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import br.com.caelum.vraptor.Get; +import br.com.caelum.vraptor.Post; +import br.com.caelum.vraptor.Resource; +import br.com.caelum.vraptor.Result; +import br.com.eselo.component.LeitorXML; +import br.com.eselo.integracao.RelatorioAvaliacao; +import br.com.eselo.model.Teste; + +@Resource +public class TestesController { + + private final Result result; + private final AvaliacaoController avaliacaoController; + + private static final Logger LOGGER = LoggerFactory + .getLogger(TestesController.class); + + public TestesController(Result _result, AvaliacaoController _avaliacaoController) { + this.result = _result; + this.avaliacaoController = _avaliacaoController; + } + + @Get("/teste") + public void form() { + } + + @Post("/teste/form") + public void form(Teste teste) { + LOGGER.debug("XML: " + teste.getXml()); + + RelatorioAvaliacao relatorioAvaliacao = new LeitorXML() + .lerAvaliacaoXML(teste.getXml()); + + avaliacaoController.calcularNota(relatorioAvaliacao); + + result.include("mensagem", "Teste realizado."); + } + +} diff --git a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/TiposTesteController.java b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/TiposTesteController.java index 6ddf4e3..d13529d 100644 --- a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/TiposTesteController.java +++ b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/TiposTesteController.java @@ -1,109 +1,109 @@ -package br.com.eselo.controller; - -import java.util.List; - -import br.com.caelum.vraptor.Get; -import br.com.caelum.vraptor.Put; -import br.com.caelum.vraptor.Resource; -import br.com.caelum.vraptor.Result; -import br.com.caelum.vraptor.Validator; -import br.com.caelum.vraptor.validator.ValidationMessage; -import br.com.eselo.annotations.Restrito; -import br.com.eselo.component.Messages; -import br.com.eselo.dao.TipoTesteDAO; -import br.com.eselo.model.TipoTeste; - -@Resource -public class TiposTesteController { - - private final TipoTesteDAO dao; - private final Result result; - private final Validator validator; - - public TiposTesteController(TipoTesteDAO _dao, Result _result, - Validator _validator) { - dao = _dao; - result = _result; - validator = _validator; - } - - @Get("/tiposTeste") - @Restrito(descricao = "TIPOS_TESTELISTA") - public List lista() { - return dao.listAll(); - } - - @Restrito(descricao = "TIPOS_TESTE_ADICIONAR") - public void form() { - } - - @Get("/tiposTeste/{id}") - @Restrito(descricao = "TIPOS_TESTE_ATUALIZAR") - public TipoTeste form(Long id) { - TipoTeste tipoTeste = dao.load(id); - - /* - if (!tipoTeste.getRecomendacoes().isEmpty()) { - result.include("mensagem", - Messages.getString("tipo_recomendacao.validacao.edit")); - result.redirectTo(TiposTesteController.class).lista(); - } - */ - - return tipoTeste; - } - - @Put("/tiposTeste") - @Restrito(descricao = "TIPOS_TESTE_ATUALIZAR") - public void atualizar(TipoTeste tipoTeste) { - TipoTeste tipoTesteCadastrada = dao.load(tipoTeste.getId()); - - validarTipoConformidade(tipoTeste); - - validator.onErrorUsePageOf(TiposTesteController.class).form( - tipoTeste.getId()); - - tipoTesteCadastrada.setTipo(tipoTeste.getTipo()); - tipoTesteCadastrada.setDescricao(tipoTeste.getDescricao()); - - dao.saveOrUpdate(tipoTesteCadastrada); - - result.include("mensagem", - Messages.getString("tipo_recomendacao.mensagem.alterada")); - result.redirectTo(TiposTesteController.class).lista(); - } - - private void validarTipoConformidade(TipoTeste tipoTeste) { - if (tipoTeste.getTipo() == null) { - validator.add(new ValidationMessage(Messages - .getString("tipo_recomendacao.validacao.tipo"), - "tipoTeste.tipo")); - } else if (tipoTeste.getDescricao() == null) { - validator.add(new ValidationMessage(Messages - .getString("tipo_recomendacao.validacao.descricao"), - "tipoTeste.descricao")); - } else if (dao.existeTipo(tipoTeste)) { - Long id = dao.getIdByDescricao(tipoTeste.getDescricao()); - - if ((tipoTeste.getId() == null && id != null) - || (tipoTeste.getId() != null && tipoTeste.getId() == id)) { - validator - .add(new ValidationMessage( - Messages.getString("tipo_recomendacao.validacao.descricao.unique"), - "tipoTeste.descricao")); - } - } - /* - else if (tipoTeste.getMaximoConformidade() == null) { - validator.add(new ValidationMessage(Messages - .getString("tipo_recomendacao.validacao.maximo"), - "tipoRecomendacao.maximoConformidade")); - } else if (tipoTeste.getMaximoConformidade() <= 0) { - validator.add(new ValidationMessage(Messages - .getString("tipo_recomendacao.validacao.maximo.min"), - "tipoRecomendacao.maximoConformidade")); - } - */ - } - -} +package br.com.eselo.controller; + +import java.util.List; + +import br.com.caelum.vraptor.Get; +import br.com.caelum.vraptor.Put; +import br.com.caelum.vraptor.Resource; +import br.com.caelum.vraptor.Result; +import br.com.caelum.vraptor.Validator; +import br.com.caelum.vraptor.validator.ValidationMessage; +import br.com.eselo.annotations.Restrito; +import br.com.eselo.component.Messages; +import br.com.eselo.dao.TipoTesteDAO; +import br.com.eselo.model.TipoTeste; + +@Resource +public class TiposTesteController { + + private final TipoTesteDAO dao; + private final Result result; + private final Validator validator; + + public TiposTesteController(TipoTesteDAO _dao, Result _result, + Validator _validator) { + dao = _dao; + result = _result; + validator = _validator; + } + + @Get("/tiposTeste") + @Restrito(descricao = "TIPOS_TESTELISTA") + public List lista() { + return dao.listAll(); + } + + @Restrito(descricao = "TIPOS_TESTE_ADICIONAR") + public void form() { + } + + @Get("/tiposTeste/{id}") + @Restrito(descricao = "TIPOS_TESTE_ATUALIZAR") + public TipoTeste form(Long id) { + TipoTeste tipoTeste = dao.load(id); + + /* + if (!tipoTeste.getRecomendacoes().isEmpty()) { + result.include("mensagem", + Messages.getString("tipo_recomendacao.validacao.edit")); + result.redirectTo(TiposTesteController.class).lista(); + } + */ + + return tipoTeste; + } + + @Put("/tiposTeste") + @Restrito(descricao = "TIPOS_TESTE_ATUALIZAR") + public void atualizar(TipoTeste tipoTeste) { + TipoTeste tipoTesteCadastrada = dao.load(tipoTeste.getId()); + + validarTipoConformidade(tipoTeste); + + validator.onErrorUsePageOf(TiposTesteController.class).form( + tipoTeste.getId()); + + tipoTesteCadastrada.setTipo(tipoTeste.getTipo()); + tipoTesteCadastrada.setDescricao(tipoTeste.getDescricao()); + + dao.saveOrUpdate(tipoTesteCadastrada); + + result.include("mensagem", + Messages.getString("tipo_recomendacao.mensagem.alterada")); + result.redirectTo(TiposTesteController.class).lista(); + } + + private void validarTipoConformidade(TipoTeste tipoTeste) { + if (tipoTeste.getTipo() == null) { + validator.add(new ValidationMessage(Messages + .getString("tipo_recomendacao.validacao.tipo"), + "tipoTeste.tipo")); + } else if (tipoTeste.getDescricao() == null) { + validator.add(new ValidationMessage(Messages + .getString("tipo_recomendacao.validacao.descricao"), + "tipoTeste.descricao")); + } else if (dao.existeTipo(tipoTeste)) { + Long id = dao.getIdByDescricao(tipoTeste.getDescricao()); + + if ((tipoTeste.getId() == null && id != null) + || (tipoTeste.getId() != null && tipoTeste.getId() == id)) { + validator + .add(new ValidationMessage( + Messages.getString("tipo_recomendacao.validacao.descricao.unique"), + "tipoTeste.descricao")); + } + } + /* + else if (tipoTeste.getMaximoConformidade() == null) { + validator.add(new ValidationMessage(Messages + .getString("tipo_recomendacao.validacao.maximo"), + "tipoRecomendacao.maximoConformidade")); + } else if (tipoTeste.getMaximoConformidade() <= 0) { + validator.add(new ValidationMessage(Messages + .getString("tipo_recomendacao.validacao.maximo.min"), + "tipoRecomendacao.maximoConformidade")); + } + */ + } + +} diff --git a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/UrlController.java b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/UrlController.java index 2039c90..481b502 100644 --- a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/UrlController.java +++ b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/UrlController.java @@ -45,7 +45,7 @@ public class UrlController { public List lista(String nUrl) { Long idUsuario = usuarioWeb.getUsuario().getId(); - + if (nUrl == null) return this.dao.listAll(idUsuario); else diff --git a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/UsuariosController.java b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/UsuariosController.java index 0f492ae..1ec3e6a 100644 --- a/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/UsuariosController.java +++ b/Desenvolvimento/Codificacao/e-Selo/src/main/java/br/com/eselo/controller/UsuariosController.java @@ -1,260 +1,260 @@ -package br.com.eselo.controller; - -import java.security.SecureRandom; -import java.util.List; - -import javax.servlet.http.HttpServletRequest; - -import org.apache.commons.lang3.RandomStringUtils; -import org.apache.commons.mail.Email; -import org.apache.commons.mail.EmailException; -import org.hibernate.Hibernate; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import br.com.caelum.vraptor.Get; -import br.com.caelum.vraptor.Path; -import br.com.caelum.vraptor.Post; -import br.com.caelum.vraptor.Put; -import br.com.caelum.vraptor.Resource; -import br.com.caelum.vraptor.Result; -import br.com.caelum.vraptor.Validator; -import br.com.caelum.vraptor.validator.ValidationMessage; -import br.com.eselo.annotations.Restrito; -import br.com.eselo.component.Mailer; -import br.com.eselo.component.TemplateMailer; -import br.com.eselo.component.UsuarioWeb; -import br.com.eselo.dao.UsuarioDAO; -import br.com.eselo.model.Usuario; - -@Resource -public class UsuariosController { - - @SuppressWarnings("unused") - private static final Logger LOGGER = LoggerFactory - .getLogger(UsuariosController.class); - - private final UsuarioDAO dao; - private final Result result; - private final Validator validator; - private final UsuarioWeb usuarioWeb; - private final Mailer mailer; - private final TemplateMailer templates; - private final HttpServletRequest request; - - public UsuariosController(UsuarioDAO _dao, Result _result, - Validator _validator, UsuarioWeb _usuarioWeb, Mailer _mailer, - TemplateMailer _templates, HttpServletRequest _request) { - dao = _dao; - result = _result; - validator = _validator; - usuarioWeb = _usuarioWeb; - mailer = _mailer; - templates = _templates; - request = _request; - } - - @Get("/usuarios") - @Restrito(descricao = "USUARIOS_LISTA") - public List lista() { - return dao.listAll(); - } - - @Get("/usuarios/lista") - @Restrito(descricao = "USUARIOS_LISTA") - public List lista(Usuario usuario) { - result.include("usuario", usuario); - return dao.listAll(usuario); - } - - @Restrito(descricao = "USUARIOS_ADICIONAR") - public void form() { - result.include("grupoList", dao.getAllGrupos()); - } - - @Get("/usuarios/{id}") - @Restrito(descricao = "USUARIOS_ATUALIZAR") - public Usuario form(Long id) { - Usuario usuario = dao.load(id); - result.include("grupoList", dao.getAllGrupos()); - return usuario; - } - - @Post("/usuarios") - @Restrito(descricao = "USUARIOS_ADICIONAR") - public void adicionar(Usuario usuario) { - result.include("grupoList", dao.getAllGrupos()); - validate(usuario); - - dao.save(usuario); - - result.include("mensagem", "Usuário salvo com sucesso."); - result.redirectTo(UsuariosController.class).lista(); - } - - - - @Put("/usuarios") - @Restrito(descricao = "USUARIOS_ATUALIZAR") - public void atualizar(Usuario usuario) { - result.include("grupoList", dao.getAllGrupos()); - validate(usuario); - - Usuario usuarioCadastrado = dao.load(usuario.getId()); - usuarioCadastrado.setNome(usuario.getNome()); - usuarioCadastrado.setCpf(usuario.getCpf()); - usuarioCadastrado.setGrupo(usuario.getGrupo()); - usuarioCadastrado.setEmail(usuario.getEmail()); - - if (usuario.getSenha() != null - && usuario.getSenha() != usuarioCadastrado.getSenha()) { - usuarioCadastrado.setHashedSenha(usuario.getSenha()); - } - - dao.saveOrUpdate(usuarioCadastrado); - - result.include("mensagem", "Usuário alterado com sucesso."); - result.redirectTo(UsuariosController.class).lista(); - } - - @Path("/usuarios/delete/{id}") - @Restrito(descricao = "USUARIOS_EXCLUIR") - public void excluir(Long id) { - dao.remove(id); - result.include("mensagem", "Usuário excluído com sucesso."); - result.redirectTo(UsuariosController.class).lista(); - } - - @Get("/login") - public void loginForm() { - - } - - @Post("/login") - public void login(Usuario usuario) { - Usuario carregado = dao.getByCpfAndSenha(usuario); - if (carregado == null) { - validator.add(new ValidationMessage("CPF e/ou senha inválidos.", - "usuario.cpf")); - } - validator.onErrorUsePageOf(UsuariosController.class).loginForm(); - - Hibernate.initialize(carregado.getGrupo()); - usuarioWeb.login(carregado); - - result.redirectTo(PainelController.class).index(); - } - - @Path("/logout") - public void logout() { - usuarioWeb.logout(); - result.redirectTo(UsuariosController.class).loginForm(); - } - - @Path("/usuarios/renovar_senha/{hash}") - @Get - public void renovarSenhaForm(String hash) { - result.include("hash", hash); - } - - @Path("/usuarios/renovar_senha") - @Post - public void renovarSenha(Usuario usuario) { - Usuario carregado = dao.getByHash(usuario.getChaveAlteracaoSenha()); - if (carregado == null) { - validator.add(new ValidationMessage("Código não encontrado.", - "usuario.senha")); - } - - if (usuario.getSenha() == null || usuario.getConfirmacaoSenha() == null) { - validator.add(new ValidationMessage("Preencha a senha e a confirmação.", - "usuario.senha")); - } - - if (!usuario.getSenha().equals(usuario.getConfirmacaoSenha())) { - validator.add(new ValidationMessage("A senha nova e confirmação não coincidem.", - "usuario.senha")); - } - - carregado.setHashedSenha(usuario.getSenha()); - carregado.setChaveAlteracaoSenha(null); - dao.saveOrUpdate(carregado); - - validator.onErrorUsePageOf(UsuariosController.class) - .renovarSenhaForm(usuario.getChaveAlteracaoSenha()); - - result.include("mensagem", - "Senha alterada com sucesso."); - result.redirectTo(UsuariosController.class).loginForm(); - } - - @Path("/usuarios/recuperar_senha") - @Get - public void recuperarSenhaForm() { - - } - - @Path("/usuarios/recuperar_senha") - @Post - public void recuperarSenha(Usuario usuario) throws EmailException { - Usuario carregado = dao.getByCpf(usuario); - if (carregado == null) { - validator.add(new ValidationMessage("CPF não encontrado.", - "usuario.cpf")); - } - - validator.onErrorUsePageOf(UsuariosController.class) - .recuperarSenhaForm(); - - String hash = RandomStringUtils.random(15, 0, 0, true, true, null, - new SecureRandom()); - - carregado.setChaveAlteracaoSenha(hash); - dao.saveOrUpdate(carregado); - - Email email = this.templates - .template("esqueciMinhaSenha") - .with("nomeUsuario", carregado.getNome()) - .with("cpfUsuario", carregado.getCpfFormatado()) - .with("urlAlteracao", - "http://" - + request.getHeader("Host") - + request.getRequestURI().replace( - "recuperar_senha", "renovar_senha") - + "/" + hash) - .to(carregado.getNome(), carregado.getEmail()); - mailer.send(email); - - result.include("mensagem", - "Email de recuperação de senha enviado com sucesso."); - result.redirectTo(UsuariosController.class).loginForm(); - } - - private void validate(Usuario usuario) { - Long idUsuarioMesmoCpf = dao.getIdByCpf(usuario.getCpf(), usuario.getId()); - - if (usuario.getNome() == null) { - validator.add(new ValidationMessage("O nome é obrigatório.", - "usuario.nome")); - } else if (usuario.getCpf() == null) { - validator.add(new ValidationMessage("O CPF é obrigatório.", - "usuario.cpf")); - } else if (usuario.getEmail() == null) { - validator.add(new ValidationMessage("O email é obrigatório.", - "usuario.email")); - } else if (usuario.getGrupo().getId() == null) { - validator.add(new ValidationMessage("O grupo é obrigatório.", - "usuario.grupo.id")); - } else if (usuario.getSenha() == null) { - validator.add(new ValidationMessage("A senha é obrigatória.", - "usuario.senha")); - } else if (idUsuarioMesmoCpf != null) { - validator.add(new ValidationMessage( - "O usuário não pode ser igual a um já existente.", - "usuario.cpf")); - } - - validator.onErrorUsePageOf(UsuariosController.class).form(); - } - -} +package br.com.eselo.controller; + +import java.security.SecureRandom; +import java.util.List; + +import javax.servlet.http.HttpServletRequest; + +import org.apache.commons.lang3.RandomStringUtils; +import org.apache.commons.mail.Email; +import org.apache.commons.mail.EmailException; +import org.hibernate.Hibernate; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import br.com.caelum.vraptor.Get; +import br.com.caelum.vraptor.Path; +import br.com.caelum.vraptor.Post; +import br.com.caelum.vraptor.Put; +import br.com.caelum.vraptor.Resource; +import br.com.caelum.vraptor.Result; +import br.com.caelum.vraptor.Validator; +import br.com.caelum.vraptor.validator.ValidationMessage; +import br.com.eselo.annotations.Restrito; +import br.com.eselo.component.Mailer; +import br.com.eselo.component.TemplateMailer; +import br.com.eselo.component.UsuarioWeb; +import br.com.eselo.dao.UsuarioDAO; +import br.com.eselo.model.Usuario; + +@Resource +public class UsuariosController { + + @SuppressWarnings("unused") + private static final Logger LOGGER = LoggerFactory + .getLogger(UsuariosController.class); + + private final UsuarioDAO dao; + private final Result result; + private final Validator validator; + private final UsuarioWeb usuarioWeb; + private final Mailer mailer; + private final TemplateMailer templates; + private final HttpServletRequest request; + + public UsuariosController(UsuarioDAO _dao, Result _result, + Validator _validator, UsuarioWeb _usuarioWeb, Mailer _mailer, + TemplateMailer _templates, HttpServletRequest _request) { + dao = _dao; + result = _result; + validator = _validator; + usuarioWeb = _usuarioWeb; + mailer = _mailer; + templates = _templates; + request = _request; + } + + @Get("/usuarios") + @Restrito(descricao = "USUARIOS_LISTA") + public List lista() { + return dao.listAll(); + } + + @Get("/usuarios/lista") + @Restrito(descricao = "USUARIOS_LISTA") + public List lista(Usuario usuario) { + result.include("usuario", usuario); + return dao.listAll(usuario); + } + + @Restrito(descricao = "USUARIOS_ADICIONAR") + public void form() { + result.include("grupoList", dao.getAllGrupos()); + } + + @Get("/usuarios/{id}") + @Restrito(descricao = "USUARIOS_ATUALIZAR") + public Usuario form(Long id) { + Usuario usuario = dao.load(id); + result.include("grupoList", dao.getAllGrupos()); + return usuario; + } + + @Post("/usuarios") + @Restrito(descricao = "USUARIOS_ADICIONAR") + public void adicionar(Usuario usuario) { + result.include("grupoList", dao.getAllGrupos()); + validate(usuario); + + dao.save(usuario); + + result.include("mensagem", "Usuário salvo com sucesso."); + result.redirectTo(UsuariosController.class).lista(); + } + + + + @Put("/usuarios") + @Restrito(descricao = "USUARIOS_ATUALIZAR") + public void atualizar(Usuario usuario) { + result.include("grupoList", dao.getAllGrupos()); + validate(usuario); + + Usuario usuarioCadastrado = dao.load(usuario.getId()); + usuarioCadastrado.setNome(usuario.getNome()); + usuarioCadastrado.setCpf(usuario.getCpf()); + usuarioCadastrado.setGrupo(usuario.getGrupo()); + usuarioCadastrado.setEmail(usuario.getEmail()); + + if (usuario.getSenha() != null + && usuario.getSenha() != usuarioCadastrado.getSenha()) { + usuarioCadastrado.setHashedSenha(usuario.getSenha()); + } + + dao.saveOrUpdate(usuarioCadastrado); + + result.include("mensagem", "Usuário alterado com sucesso."); + result.redirectTo(UsuariosController.class).lista(); + } + + @Path("/usuarios/delete/{id}") + @Restrito(descricao = "USUARIOS_EXCLUIR") + public void excluir(Long id) { + dao.remove(id); + result.include("mensagem", "Usuário excluído com sucesso."); + result.redirectTo(UsuariosController.class).lista(); + } + + @Get("/login") + public void loginForm() { + + } + + @Post("/login") + public void login(Usuario usuario) { + Usuario carregado = dao.getByCpfAndSenha(usuario); + if (carregado == null) { + validator.add(new ValidationMessage("CPF e/ou senha inválidos.", + "usuario.cpf")); + } + validator.onErrorUsePageOf(UsuariosController.class).loginForm(); + + Hibernate.initialize(carregado.getGrupo()); + usuarioWeb.login(carregado); + + result.redirectTo(PainelController.class).index(); + } + + @Path("/logout") + public void logout() { + usuarioWeb.logout(); + result.redirectTo(UsuariosController.class).loginForm(); + } + + @Path("/usuarios/renovar_senha/{hash}") + @Get + public void renovarSenhaForm(String hash) { + result.include("hash", hash); + } + + @Path("/usuarios/renovar_senha") + @Post + public void renovarSenha(Usuario usuario) { + Usuario carregado = dao.getByHash(usuario.getChaveAlteracaoSenha()); + if (carregado == null) { + validator.add(new ValidationMessage("Código não encontrado.", + "usuario.senha")); + } + + if (usuario.getSenha() == null || usuario.getConfirmacaoSenha() == null) { + validator.add(new ValidationMessage("Preencha a senha e a confirmação.", + "usuario.senha")); + } + + if (!usuario.getSenha().equals(usuario.getConfirmacaoSenha())) { + validator.add(new ValidationMessage("A senha nova e confirmação não coincidem.", + "usuario.senha")); + } + + carregado.setHashedSenha(usuario.getSenha()); + carregado.setChaveAlteracaoSenha(null); + dao.saveOrUpdate(carregado); + + validator.onErrorUsePageOf(UsuariosController.class) + .renovarSenhaForm(usuario.getChaveAlteracaoSenha()); + + result.include("mensagem", + "Senha alterada com sucesso."); + result.redirectTo(UsuariosController.class).loginForm(); + } + + @Path("/usuarios/recuperar_senha") + @Get + public void recuperarSenhaForm() { + + } + + @Path("/usuarios/recuperar_senha") + @Post + public void recuperarSenha(Usuario usuario) throws EmailException { + Usuario carregado = dao.getByCpf(usuario); + if (carregado == null) { + validator.add(new ValidationMessage("CPF não encontrado.", + "usuario.cpf")); + } + + validator.onErrorUsePageOf(UsuariosController.class) + .recuperarSenhaForm(); + + String hash = RandomStringUtils.random(15, 0, 0, true, true, null, + new SecureRandom()); + + carregado.setChaveAlteracaoSenha(hash); + dao.saveOrUpdate(carregado); + + Email email = this.templates + .template("esqueciMinhaSenha") + .with("nomeUsuario", carregado.getNome()) + .with("cpfUsuario", carregado.getCpfFormatado()) + .with("urlAlteracao", + "http://" + + request.getHeader("Host") + + request.getRequestURI().replace( + "recuperar_senha", "renovar_senha") + + "/" + hash) + .to(carregado.getNome(), carregado.getEmail()); + mailer.send(email); + + result.include("mensagem", + "Email de recuperação de senha enviado com sucesso."); + result.redirectTo(UsuariosController.class).loginForm(); + } + + private void validate(Usuario usuario) { + Long idUsuarioMesmoCpf = dao.getIdByCpf(usuario.getCpf(), usuario.getId()); + + if (usuario.getNome() == null) { + validator.add(new ValidationMessage("O nome é obrigatório.", + "usuario.nome")); + } else if (usuario.getCpf() == null) { + validator.add(new ValidationMessage("O CPF é obrigatório.", + "usuario.cpf")); + } else if (usuario.getEmail() == null) { + validator.add(new ValidationMessage("O email é obrigatório.", + "usuario.email")); + } else if (usuario.getGrupo().getId() == null) { + validator.add(new ValidationMessage("O grupo é obrigatório.", + "usuario.grupo.id")); + } else if (usuario.getSenha() == null) { + validator.add(new ValidationMessage("A senha é obrigatória.", + "usuario.senha")); + } else if (idUsuarioMesmoCpf != null) { + validator.add(new ValidationMessage( + "O usuário não pode ser igual a um já existente.", + "usuario.cpf")); + } + + validator.onErrorUsePageOf(UsuariosController.class).form(); + } + +} -- libgit2 0.21.2