public async Task <CommandResponse> Handle(AtualizarPerfilCommand request, CancellationToken cancellationToken)
        {
            if (!await PerfilExitente(request))
            {
                return(await Task.FromResult(CommandResponse.Fail));
            }

            var perfil = this.DefinirPerfil(request);

            var perfilExistente = await _perfilRepository.Buscar(p => p.Identifacao.Nome == request.Nome && p.Id != request.Id);

            if (perfilExistente.Any())
            {
                await _mediator.Publish(new DomainNotification(request.GetType().Name, $"Um perfil com o nome {request.Nome} já existe."));

                return(await Task.FromResult(CommandResponse.Fail));
            }

            _perfilRepository.Atualizar(perfil);

            if (await Commit())
            {
                await _mediator.Send(new AtribuirPermissaoCommand(request.Id, request.Atribuicoes));

                await _mediator.Publish(new PerfilAtualizadoEvent(perfil));
            }

            return(await Task.FromResult(CommandResponse.Ok));
        }
Exemple #2
0
        public IActionResult AtualizarPerfil([FromBody] PerfilDomain perfil, [FromRoute] int id)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    var errors = ModelState.Select(x => x.Value.Errors)
                                 .Where(y => y.Count > 0)
                                 .ToList();

                    return(BadRequest(errors));
                }

                var perfil_ = perfilRepository.BuscarPorId(perfil.PerfilId);
                if (perfil_ == null)
                {
                    return(NotFound("Usuário nâo encontrado."));
                }

                perfil_.Nome    = perfil.Nome;
                perfil_.MiniBio = perfil.MiniBio;
                perfil_.Cep     = perfil.Cep;
                perfil_.SedeId  = perfil.SedeId;
                perfilRepository.Atualizar(perfil_);
                return(Ok(perfil_));
            }
            catch (System.Exception e)
            {
                return(BadRequest(e.Message));
            }
        }
Exemple #3
0
        public ActionResult AtualizarPerfil(Perfil perfil)
        {
            try
            {
                _context.Atualizar(perfil.Id, perfil);

                return(Ok());
            }
            catch
            {
                return(BadRequest());
            }
        }
        public void Editar(GeradorRelatorio geradorRelatorio)
        {
            ValidarModelo(geradorRelatorio);

            var geradorAnterior = _geradorRelatorioRepository.PesquisarPorId(geradorRelatorio.Id);
            var perfilAntigo    = _perfilRepository.Pesquisar(x => x.Funcionalidade == geradorAnterior.Alias).SingleOrDefault();

            _geradorRelatorioRepository.EntityStateDetached(geradorAnterior);
            _geradorRelatorioRepository.Atualizar(geradorRelatorio);

            _perfilRepository.EntityStateDetached(perfilAntigo);
            perfilAntigo.Funcionalidade = geradorRelatorio.Alias;
            perfilAntigo.Descricao      = geradorRelatorio.Nome;

            _perfilRepository.Atualizar(perfilAntigo);
        }
        public async Task <bool> DeletarPerfilAsync(Perfil perfil)
        {
            var usuariosComPerfil = await _usuarioRepo.Buscar(u => u.PerfilId == perfil.Id);

            if (usuariosComPerfil.Any())
            {
                await _mediator.Publish(new DomainNotification(GetType().Name, "O perfil esta em uso e não pode ser deletado."));

                return(await Task.FromResult(false));
            }

            if (perfil.Atribuicoes.Any())
            {
                perfil.Deletar();
                _perfilRepo.Atualizar(perfil);
                return(await Task.FromResult(true));
            }

            _perfilRepo.Deletar(perfil);
            return(await Task.FromResult(true));
        }