public async Task <IActionResult> Edit(long?id, [Bind("DepartamentoID, Nome, InstituicaoID")] Departamento departamento)
{
if (id != departamento.DepartamentoID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(departamento);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DepartamentoExists(departamento.DepartamentoID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewBag.Instituicoes = new SelectList(_context.Instituicoes.OrderBy(b => b.Nome), "InstituicaoID", "Nome", departamento.InstituicaoID);
return(View(departamento));
}
public async Task<IActionResult> Edit(long? id, [Bind("IdTurma, Periodo, NomeTurma, IdCurso")] Turma turma)
{
if (id != turma.IdTurma)
{
return NotFound();
}
if (ModelState.IsValid)
{
try
{
_context.Update(turma);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TurmaExists(turma.IdTurma))
{
NotFound();
return NotFound();
}
else
{
throw;
}
}
return RedirectToAction(nameof(Index));
}
ViewBag.Cursos = new SelectList(_context.Cursos.OrderBy(b => b.NomeCurso), "IdCurso", "NomeCurso", turma.IdCurso);
return View(turma);
}
public async Task <IActionResult> Edit(long?id, [Bind("Id,Nome")] Modalidade modalidade)
{
if (id != modalidade.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(modalidade);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ModalidadeExists(modalidade.Id))
{
NotFound();
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(modalidade));
}
public async Task <IActionResult> Edit(long?id, [Bind("DepartamentoId, Nome")] Departamento departamento)
{
if (id != departamento.DepartamentoID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(departamento);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DepartamentoExists(departamento.DepartamentoID))
{
return(NotFound());
}
else
{
throw;
}
}
}
return(View(departamento));
}
public async Task <IActionResult> Edit(long?id, [Bind("AlunoID, AlunoNome, Matricula, ProjetoID, ProjetoNome, Status")] Aluno aluno)
{
if (id != aluno.AlunoID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(aluno);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AlunoExists(aluno.AlunoID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewBag.Projetos = new SelectList(_context.Projetos.OrderBy(b => b.ProjetoNome), "ProjetoID", "ProjetoNome", aluno.ProjetoID);
return(View(aluno));
}
public async Task <Frequencia> AtualizarFrequencia(Frequencia frequencia)
{
_context.Update(frequencia);
await _context.SaveChangesAsync();
return(frequencia);
}
public async Task <IActionResult> Edit(long?id, [Bind("Id", "Nome")] UnidadeCurricular unidadecurricular)
{
if (id != unidadecurricular.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(unidadecurricular);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UnidadeCurricularExists(unidadecurricular.Id))
{
NotFound();
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(unidadecurricular));
}
public async Task <IActionResult> Edit(long?id, [Bind("DepartamentoID,Nome")] Departamento departamento)
{
if (id != departamento.DepartamentoID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(departamento);
await _context.SaveChangesAsync();
}
catch
{
if (!DepartamentoExists(departamento.DepartamentoID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(departamento));
}
public async Task <IActionResult> Edit(long?id, [Bind("Id, Nome, Endereço")] Instituicao instituicao)
{
if (id != instituicao.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(instituicao);
TempData["Message"] = "Instituição " + instituicao.Nome + " foi atualizada com sucesso.";
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!InstituicaoExists(instituicao.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(instituicao));
}
public async Task <IActionResult> Edit(long?id, [Bind("InstituicaoID,Nome,Endereco")] Instituicao instituicao)
{
if (id != instituicao.InstituicaoID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(instituicao);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!InstituicaoExists(instituicao.InstituicaoID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(instituicao));
}
public async Task <IActionResult> Edit(long?id, [Bind("Id", "IdTurma", "Data", "HorarioInicio", "HorarioFim", "IdUc", "IdFunc")] Aula aula)
{
if (id != aula.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
// se o usuário tiver contrato intermitente e
// se a data da aula não coincidir com a folga do funcionário, entra no if
if (isIntermitente(aula) && dayLimit(aula))
{
ViewData["MSG_ERR"] = "Erro! A data selecionada coincide com a folga desse Funcionário!";
}
else
{
// se não houver aula no mesmo dia e horário, entra no if
if (!haveAulaT(aula, id) && !haveAulaF(aula, id))
{
// se o professor não ultrapassar o limite de horas trabalhadas por dia, entra no if
if (calculaHora(aula))
{
try
{
// atualizando o banco
_context.Update(aula);
await _context.SaveChangesAsync();
}
catch (DbException)
{
if (!AulaExists(aula.Id))
{
NotFound();
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
else
{
ViewData["MSG_ERR"] = "Erro! O Funcionário já ultrapassou o limite de horas trabalhadas no dia selecionado!";
}
}
else
{
ViewData["MSG_ERR"] = "Erro! Já existe uma aula com essa turma ou com esse funcionário cadastrada nessa data e coincidente com este horário";
}
}
}
ViewBag.Turmas = _context.Turmas.OrderBy(t => t.Sigla).ToList();
ViewBag.Unidades = _context.UnidadeCurriculares.OrderBy(u => u.Nome).ToList();
ViewBag.Funcionarios = _context.Funcionarios.OrderBy(f => f.NomeCompleto).ToList();
return(View(aula));
}
public async Task <Aluno> GravarAluno(Aluno aluno)
{
if (aluno.AlunoID == null)
{
_context.Alunos.Add(aluno);
}
else
{
_context.Update(aluno);
}
await _context.SaveChangesAsync();
return(aluno);
}
public async Task <Professor> GravarProfessor(Professor professor)
{
if (professor.ProfessorID == null)
{
_context.Professores.Add(professor);
}
else
{
_context.Update(professor);
}
await _context.SaveChangesAsync();
return(professor);
}
public async Task <Academico> GravarAcademico(Academico academico)
{
if (academico.AcademicoID == null)
{
_context.Academicos.Add(academico);
}
else
{
_context.Update(academico);
}
await _context.SaveChangesAsync();
return(academico);
}
public async Task <Instituicao> GravarInstituicao(Instituicao instituicao)
{
if (instituicao.InstituicaoID == null)
{
_context.Instituicoes.Add(instituicao);
}
else
{
_context.Update(instituicao);
}
await _context.SaveChangesAsync();
return(instituicao);
}
public async Task <Departamento> GravarDepartamento(Departamento departamento)
{
if (departamento.DepartamentoID == null)
{
_context.Departamentos.Add(departamento);
}
else
{
_context.Update(departamento);
}
await _context.SaveChangesAsync();
return(departamento);
}
public async Task <Curso> GravarCurso(Curso curso)
{
if (curso.CursoID == null)
{
_context.Cursos.Add(curso);
}
else
{
_context.Update(curso);
}
await _context.SaveChangesAsync();
return(curso);
}
public async Task <IActionResult> Edit(long?id, [Bind("Id", "NomeCompleto", "Email", "Senha", "ConfirmarSenha", "IdPerfil", "IdContrato", "Horario", "CargaHorariaSemanal")] Funcionario funcionario, int[] Idcursos)
{
if (id != funcionario.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(funcionario);
await _context.SaveChangesAsync();
// Deletando os registros ligados a esse funcionario na tabela FuncionarioCurso, é necessário fazer essa
// exclusão por não haver a possibilidade de alterar registros de uma tabela associativa
deleteFuncionarioCurso(funcionario.Id);
// retorna o atual funcionario
var currentFuncionario = _context.Funcionarios.Where(f => f.Id.Equals(id)).SingleOrDefault();
// cria novamente a relação Funcionario -> Curso, populando a tabela associativa
foreach (var curso in Idcursos)
{
FuncionarioCurso funcionarioCurso = new FuncionarioCurso();
funcionarioCurso.IdCurso = curso;
funcionarioCurso.IdFunc = currentFuncionario.Id;
_context.Add(funcionarioCurso);
await _context.SaveChangesAsync();
}
}
catch (DbUpdateConcurrencyException)
{
if (!FuncionarioExists(funcionario.Id))
{
NotFound();
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewBag.Perfis = new SelectList(_context.Perfis.OrderBy(i => i.Nivel), "Id", "Nivel", funcionario.IdPerfil);
ViewBag.Contratos = new SelectList(_context.Contratos.OrderBy(i => i.Tipo), "Id", "Tipo", funcionario.IdContrato);
ViewBag.Cursos = new MultiSelectList(_context.Cursos.OrderBy(c => c.Nome), "Id", "Nome");
return(View(funcionario));
}
public async Task <IActionResult> Edit(long?id, [Bind("Id", "IdCurso", "Modulo", "Sigla", "Ano", "Semestre")] Turma turma)
{
if (id != turma.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(turma);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TurmaExists(turma.Id))
{
NotFound();
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewBag.Cursos = _context.Cursos.OrderBy(b => b.Nome).ToList();
ViewBag.Semestre = new[]
{
new SelectListItem()
{
Value = "", Text = "Selecione o Semestre"
},
new SelectListItem()
{
Value = "Primeiro", Text = "Primeiro"
},
new SelectListItem()
{
Value = "Segundo", Text = "Segundo"
}
};
return(View(turma));
}
public bool AlterarSenha(int id, string Senha, string NovaSenha)
{
Login loginDB = _dbContext.Logins.Where(l => l.LoginID == id && l.Senha == Senha).FirstOrDefault();
if (loginDB != null)
{
loginDB.Senha = NovaSenha;
_dbContext.Update(loginDB);
_dbContext.SaveChanges();
return(true);
}
else
{
return(false);
}
}
public async Task <IActionResult> Edit(long?id, [Bind("Id", "Nome", "IdMod", "CargaHoraria", "Sigla")] Curso curso, int[] UnidadeId)
{
if (id != curso.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(curso);
await _context.SaveChangesAsync();
deleteCursoUnidade(id);
var ucs = _context.CursoUnidadeCurriculares.Where(c => c.IdCurso.Equals(id)).ToList();
// Para cada unidade selecionada cria a relação Curso -> Unidades Curriculares
foreach (var unidade in UnidadeId)
{
CursoUnidadeCurricular cursoUnidade = new CursoUnidadeCurricular();
cursoUnidade.IdCurso = curso.Id;
cursoUnidade.IdUc = unidade;
_context.Add(cursoUnidade);
await _context.SaveChangesAsync();
}
}
catch (DbUpdateConcurrencyException)
{
if (!CursoExists(curso.Id))
{
NotFound();
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewBag.Modalidades = new SelectList(_context.Modalidades.OrderBy(i => i.Nome), "Id", "Nome", curso.IdMod);
ViewBag.Unidades = new MultiSelectList(_context.UnidadeCurriculares.OrderBy(u => u.Nome), "Id", "Nome");
return(View(curso));
}
public async Task <IActionResult> Edit(long?id, [Bind("BandaID, Nome, numIntegrantes, Email, CatMusical, numAlbuns")]
Banda banda)
{
if (id != banda.BandaID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(banda);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch (DbUpdateException ex)
{
ModelState.AddModelError(ex.Message, "Falha ao atualizar");
}
}
return(View(banda));
}
public async Task <IActionResult> Edit(long?id, [Bind("ClienteId, Nome, Idade, Sexo, Email, Telefone")]
Cliente cliente)
{
if (id != cliente.ClienteId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(cliente);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch (DbUpdateException ex)
{
ModelState.AddModelError(ex.Message, "Falha ao atualizar");
}
}
return(View(cliente));
}
public async Task <IActionResult> Edit(long?id, [Bind("CarroId, Marca, Modelo, Cor, NumRodas, NumChassi")]
Carro carro)
{
if (id != carro.CarroId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(carro);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch (DbUpdateException ex)
{
ModelState.AddModelError(ex.Message, "Falha ao atualizar");
}
}
return(View(carro));
}
public async Task <IActionResult> Edit(long?id, [Bind("MusicoID, Nome, Idade, Instrumento, Telefone, Sexo")]
Musico musico)
{
if (id != musico.MusicoID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(musico);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch (DbUpdateException ex)
{
ModelState.AddModelError(ex.Message, "Falha ao atualizar");
}
}
return(View(musico));
}
public void AlterarDados(Carteira carteira)
{
_dbContext.Update(carteira);
_dbContext.SaveChanges();
}
public void AlterarEstrategia(Estrategia estrategia)
{
_dbContext.Update(estrategia);
_dbContext.SaveChanges();
}
public void AlterarCadastro(Usuario usuario)
{
_dbContext.Update(usuario);
_dbContext.SaveChanges();
}
public void AlterarDadosTrader(Trader trader)
{
_dbContext.Update(trader);
_dbContext.SaveChanges();
}
public void AlterarOperacoes(Operacao operacao)
{
_dbContext.Update(operacao);
_dbContext.SaveChanges();
}