コード例 #1
0
        public async Task <IActionResult> Edit(int id, [Bind("formacaoId,nome_instituicao,nome_curso,nivel,competencias,dataInicio,dataFim")] formacao formacao)
        {
            if (id != formacao.formacaoId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(formacao);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!formacaoExists(formacao.formacaoId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(formacao));
        }
コード例 #2
0
        public async Task <IActionResult> Edit(int id, [Bind("ContactoId,Nome,Email,Mensagem")] Contacto contacto)
        {
            if (id != contacto.ContactoId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(contacto);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ContactoExists(contacto.ContactoId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(contacto));
        }
コード例 #3
0
        public async Task <IActionResult> Edit(int id, [Bind("skillsId,descricao_skills")] skills skills)
        {
            if (id != skills.skillsId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(skills);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!skillsExists(skills.skillsId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(skills));
        }
コード例 #4
0
        public async Task <IActionResult> Edit(int id, [Bind("FormAcademicaId,Instituição,Nome,Duração,DataDeConclusão")] FormAcademica formAcademica)
        {
            if (id != formAcademica.FormAcademicaId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(formAcademica);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!FormAcademicaExists(formAcademica.FormAcademicaId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(formAcademica));
        }
コード例 #5
0
        public async Task <IActionResult> Edit(int id, [Bind("SobreMimId,Sobre")] SobreMim sobreMim)
        {
            if (id != sobreMim.SobreMimId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(sobreMim);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!SobreMimExists(sobreMim.SobreMimId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(sobreMim));
        }
コード例 #6
0
        public async Task <IActionResult> Edit(int id, [Bind("experiencia_profissionalId,funcao,empresa,descricao_exp,dataInicio,dataFim")] experiencia_profissional experiencia_profissional)
        {
            if (id != experiencia_profissional.experiencia_profissionalId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(experiencia_profissional);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!experiencia_profissionalExists(experiencia_profissional.experiencia_profissionalId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(experiencia_profissional));
        }
        public async Task <IActionResult> Edit(int id, [Bind("ExpProfissionalId,Empresa,Funcao,Detalhes,Data")] ExpProfissional expProfissional)
        {
            if (id != expProfissional.ExpProfissionalId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(expProfissional);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ExpProfissionalExists(expProfissional.ExpProfissionalId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(expProfissional));
        }
        public async Task <IActionResult> Edit(int id, [Bind("distincao_premiosId,descricao_distincao")] distincao_premios distincao_premios)
        {
            if (id != distincao_premios.distincao_premiosId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(distincao_premios);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!distincao_premiosExists(distincao_premios.distincao_premiosId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(distincao_premios));
        }
        public async Task <IActionResult> Edit(int id, [Bind("outras_informacoesId,descricao_informacao")] outras_informacoes outras_informacoes)
        {
            if (id != outras_informacoes.outras_informacoesId)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(outras_informacoes);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!outras_informacoesExists(outras_informacoes.outras_informacoesId))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(outras_informacoes));
        }