Exemplo n.º 1
0
        public void Atualizar(int id, TipoHabilidade tipoAtt)
        {
            TipoHabilidade tipoBuscado = ctx.TipoHabilidades.Find(id);

            if (tipoAtt.NomeTipo != null)
            {
                tipoBuscado.NomeTipo = tipoAtt.NomeTipo;
            }

            ctx.SaveChanges();
        }
Exemplo n.º 2
0
        public void Deletar(int id)
        {
            // Busca um tipoHabilidade através do seu id
            TipoHabilidade tipoHabilidadeBuscado = ctx.TipoHabilidades.Find(id);

            // Remove o personagem que foi buscado
            ctx.TipoHabilidades.Remove(tipoHabilidadeBuscado);

            // Salva as alterações no banco de dados
            ctx.SaveChanges();
        }
        public void Atualizar(int id, TipoHabilidade tipoHabilidadeAtualizado)
        {
            TipoHabilidade tipoHabilidadeBuscado = ctx.TipoHabilidades.Find(id);

            if (tipoHabilidadeAtualizado.TipoHabilidade1 != null)
            {
                tipoHabilidadeBuscado.TipoHabilidade1 = tipoHabilidadeAtualizado.TipoHabilidade1;
            }

            ctx.TipoHabilidades.Update(tipoHabilidadeBuscado);
            ctx.SaveChanges();
        }
        public async Task <IActionResult> Post([FromBody] TipoHabilidade tipoHabilidade)
        {
            try
            {
                var result = await tipoHabilidadeRepo.Insert(tipoHabilidade);

                return(StatusCode(201, result));
            }
            catch (Exception ex)
            {
                return(StatusCode(500, new { message = ex.Message }));
            }
        }
        public IActionResult Post(TipoHabilidade TipoHabilidadeNovo)
        {
            try
            {
                _ITipoHabilidadeRepository.Create(TipoHabilidadeNovo);

                return(StatusCode(201));
            }
            catch (Exception ex)
            {
                return(BadRequest(ex));
            }
        }
        //Atualiza uma Habilidade
        public void Atualizar(int id, TipoHabilidade tipoHabilidadeAtualizada)
        {
            TipoHabilidade tipoHabilidadeBuscada = ctx.TipoHabilidade.Find(id);

            if (tipoHabilidadeBuscada.Tipo != null)
            {
                tipoHabilidadeBuscada.Tipo = tipoHabilidadeAtualizada.Tipo;
            }

            ctx.Update(tipoHabilidadeBuscada);

            ctx.SaveChanges();
        }
        public IActionResult Put(TipoHabilidade TipoHabilidadeAtualizado, int Id)
        {
            try
            {
                _ITipoHabilidadeRepository.Update(TipoHabilidadeAtualizado, Id);

                return(StatusCode(204));
            }
            catch (Exception ex)
            {
                return(BadRequest(ex));
            }
        }
        public void Update(TipoHabilidade TipoHabilidadeAtualizado, int Id)
        {
            TipoHabilidade TipoHabilidadeBuscado = ReadById(Id);

            if (TipoHabilidadeAtualizado.NomeTipoHabilidade != null)
            {
                TipoHabilidadeBuscado.NomeTipoHabilidade = TipoHabilidadeAtualizado.NomeTipoHabilidade;

                ctx.TipoHabilidades.Update(TipoHabilidadeBuscado);

                ctx.SaveChanges();
            }
        }
        public IActionResult CadastrarTipoHabilidade(TipoHabilidade NovoTipoHabilidade)
        {
            try
            {
                _tipoHabilidadeRepository.CadastrarTipoHabilidade(NovoTipoHabilidade);

                return(StatusCode(201));
            }
            catch (Exception erro)
            {
                return(BadRequest(erro));
            }
        }
        public void AtualizarTipoHabilidade(int id, TipoHabilidade AtualizarTipoHabilidade)
        {
            TipoHabilidade TipoHabilidadeBuscada = ctx.TipoHabilidades.Find(id);


            if (AtualizarTipoHabilidade.NomeTipoHabilidade != null)
            {
                TipoHabilidadeBuscada.NomeTipoHabilidade = AtualizarTipoHabilidade.NomeTipoHabilidade;
            }

            ctx.TipoHabilidades.Update(TipoHabilidadeBuscada);

            ctx.SaveChanges();
        }
        public void Atualizar(int id, TipoHabilidade tipoHabilidadeAtualizada)
        {
            //Busca um tipo de habilidade através do seu id
            TipoHabilidade tipoHabilidadeBuscada = ctx.TipoHabilidades.Find(id);

            //Verifica se o nome do tipo de habilidade foi informado
            if (tipoHabilidadeBuscada.NomeTipoHabilidade != null)
            {
                //Atribui os novos valores aos campos existentes
                tipoHabilidadeBuscada.NomeTipoHabilidade = tipoHabilidadeAtualizada.NomeTipoHabilidade;
            }

            //Atualiza o tipo de habilidade que foi buscado
            ctx.Update(tipoHabilidadeBuscada);

            //Salva as informações para serem gravadas no banco de dados
            ctx.SaveChanges();
        }
        public IActionResult RemoverTipoHabilidade(int id)
        {
            TipoHabilidade tipoHabilidadeBuscado = _tipoHabilidadeRepository.BuscarTipoHabilidade(id);

            if (tipoHabilidadeBuscado == null)
            {
                return(NotFound("Tipo de Habilidade não encontrada"));
            }

            try
            {
                _tipoHabilidadeRepository.DeletarTipoHabilidade(id);

                return(NoContent());
            }
            catch (Exception erro)
            {
                return(BadRequest(erro));
            }
        }
        public IActionResult Atualizar(int id, TipoHabilidade tipoAtt)
        {
            _tipoHabilidade.Atualizar(id, tipoAtt);

            return(StatusCode(204));
        }
        public void CadastrarTipoHabilidade(TipoHabilidade CadastrarTipoHabilidade)
        {
            ctx.TipoHabilidades.Add(CadastrarTipoHabilidade);

            ctx.SaveChanges();
        }
        //Cadastra um novo tipo de Habilidade
        public void Cadastrar(TipoHabilidade novoTipoHabilidade)
        {
            ctx.TipoHabilidade.Add(novoTipoHabilidade);

            ctx.SaveChanges();
        }
Exemplo n.º 16
0
 public Habilidade(int id, TipoHabilidade tipo, string nome)
 {
     Id   = id;
     Tipo = tipo;
     Nome = nome;
 }
        public IActionResult Cadastrar(TipoHabilidade novoTipo)
        {
            _tipoHabilidade.Cadastrar(novoTipo);

            return(StatusCode(201));
        }
 public void Cadastrar(TipoHabilidade novoTipoHabilidade)
 {
     throw new NotImplementedException();
 }
 public void Atualizar(int id, TipoHabilidade tipoHabilidadeUpdate)
 {
     throw new NotImplementedException();
 }
        public IActionResult Post(TipoHabilidade novoTipoH)
        {
            _tipoHabilidadeRepository.Cadastrar(novoTipoH);

            return(StatusCode(201));
        }
        public IActionResult Put(int id, TipoHabilidade tipoHabilidadeAtualizada)
        {
            _tipoHabilidadeRepository.Atualizar(id, tipoHabilidadeAtualizada);

            return(StatusCode(204));
        }
        public void Create(TipoHabilidade NovoTipoHabilidade)
        {
            ctx.TipoHabilidades.Add(NovoTipoHabilidade);

            ctx.SaveChanges();
        }