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 <Curso> AdicionarCurso(Curso curso)
{
_context.Cursos.Add(curso);
await _context.SaveChangesAsync();
return(curso);
}
public async Task <Frequencia> GravarFrequencia(Frequencia frequencia)
{
_context.Frequencias.Add(frequencia);
await _context.SaveChangesAsync();
return(frequencia);
}
public async Task <IActionResult> Create([Bind("Nome")] Modalidade modalidade)
{
try
{
if (ModelState.IsValid)
{
if (!haveModalidade(modalidade))
{
_context.Add(modalidade);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
else
{
ViewData["MSG_E"] = "Já existe uma Modalidade cadastrada com esse Nome.";
}
}
}
catch (DbUpdateException)
{
ModelState.AddModelError("", "Não foi possível inserir os dados.");
}
return(View(modalidade));
}
public async Task <IActionResult> Create([Bind("Id", "NomeCompleto", "Email", "Senha", "ConfirmarSenha", "IdPerfil", "IdContrato", "Horario", "CargaHorariaSemanal")] Funcionario funcionario, int[] Idcursos)
{
try
{
if (ModelState.IsValid)
{
// se não houver um funcionario com o mesmo e-mail
if (!haveFuncionario(funcionario))
{
_context.Add(funcionario);
await _context.SaveChangesAsync();
var currentFuncionario = _context.Funcionarios.Where(f => f.Email.Equals(funcionario.Email)).SingleOrDefault();
// criando a relação Funcionario -> Curso, e 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();
}
return(RedirectToAction(nameof(Index)));
}
ViewData["MSG_E"] = "Já existe um Funcionario cadastrado com esse e-mail.";
}
}
catch (DbUpdateException)
{
ModelState.AddModelError("", "Não foi possível inserir os dados.");
}
var perfis = _context.Perfis.OrderBy(i => i.Nivel).ToList();
perfis.Insert(0, new Perfil()
{
Id = 0, Nivel = "Selecione o Perfil de Funcionário"
});
ViewBag.Perfis = perfis;
var contratos = _context.Contratos.OrderBy(i => i.Tipo).ToList();
contratos.Insert(0, new Contrato()
{
Id = 0, Tipo = "Selecione o Tipo de Contrato do Funcionário"
});
ViewBag.Contratos = contratos;
var cursos = _context.Cursos.OrderBy(c => c.Nome).ToList();
cursos.Insert(0, new Curso()
{
Id = 0, Nome = "Selecione os Cursos que esse Funcionário está relacionado"
});
ViewBag.Cursos = new MultiSelectList(cursos, "Id", "Nome");
return(View(funcionario));
}
public async Task <IActionResult> Create([Bind("DepartamentoID,Nome")] Departamento departamento)
{
if (ModelState.IsValid)
{
_context.Add(departamento);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(departamento));
}
public async Task <IActionResult> Create([Bind("InstituicaoID,Nome,Endereco")] Instituicao instituicao)
{
if (ModelState.IsValid)
{
_context.Add(instituicao);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(instituicao));
}
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 <Calendario> GravarCalendario(Calendario calendario)
{
if (calendario.DataID == null)
{
_context.Calendarios.Add(calendario);
}
else
{
_context.Calendarios.Update(calendario);
}
await _context.SaveChangesAsync();
return(calendario);
}
public async Task <IActionResult> DeleteConfirmed(long?id)//(Instituicao instituicao)
{
//var instituicao = await _context.Instituicoes.SingleOrDefaultAsync(m => m.InstituicaoID == id);
//_context.Instituicoes.Remove(instituicao);
var instituicao = await EliminiarInstituicaoPorId((long)id);
TempData["Message"] = "Instituição " + instituicao.Nome.ToUpper() + " foi removida";
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
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 <IActionResult> Create([Bind("Id", "Nome", "IdMod", "CargaHoraria", "Sigla")] Curso curso, int[] UnidadeId)
{
try
{
if (ModelState.IsValid)
{
// se não existir um curso com esse nome já cadastrado
if (!haveCursos(curso))
{
_context.Add(curso);
await _context.SaveChangesAsync();
var currentCurso = _context.Cursos.Where(c => c.Nome.Equals(curso.Nome)).SingleOrDefault();
// Para cada unidade selecionada cria a relação Curso -> Unidades Curriculares
foreach (var ids in UnidadeId)
{
CursoUnidadeCurricular cursoUnidade = new CursoUnidadeCurricular();
cursoUnidade.IdCurso = currentCurso.Id;
cursoUnidade.IdUc = ids;
_context.Add(cursoUnidade);
await _context.SaveChangesAsync();
}
return(RedirectToAction(nameof(Index)));
}
ViewData["MSG_E"] = "Já existe um Curso cadastrado com esse nome.";
}
}
catch (DbUpdateException)
{
ModelState.AddModelError("", "Não foi possível inserir os dados.");
}
var modalidade = _context.Modalidades.OrderBy(i => i.Nome).ToList();
modalidade.Insert(0, new Modalidade()
{
Id = 0, Nome = "Selecione a Modalidade"
});
ViewBag.Modalidades = modalidade;
var unidades = _context.UnidadeCurriculares.OrderBy(u => u.Nome).ToList();
unidades.Insert(0, new UnidadeCurricular()
{
Id = 0, Nome = "Selecione as Unidades Curriculares"
});
ViewBag.Unidades = new MultiSelectList(unidades, "Id", "Nome");
return(View(curso));
}
public async Task <Projeto> GravarProjeto(Projeto projeto)
{
if (projeto.ProjetoID == null)
{
_context.Projetos.Add(projeto);
}
else
{
_context.Projetos.Update(projeto);
}
await _context.SaveChangesAsync();
return(projeto);
}
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 <Aluno> GravarAluno(Aluno aluno)
{
if (aluno.AlunoID == null)
{
_context.Alunos.Add(aluno);
}
else
{
_context.Update(aluno);
}
await _context.SaveChangesAsync();
return(aluno);
}
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 <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> Create([Bind("Id", "IdTurma", "Data", "HorarioInicio", "HorarioFim", "IdUc", "IdFunc")] Aula aula)
{
try
{
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 na data e horário passados, insere a aula no banco
if (!haveAulaT(aula, null) && !haveAulaF(aula, null))
{
// se o funcionario não ultrapassar as 10 horas de trabalho
if (calculaHora(aula))
{
// adicionando a aula ao banco
_context.Add(aula);
await _context.SaveChangesAsync();
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";
}
}
}
}
catch (Exception)
{
throw;
}
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());
}
public async Task<IActionResult> Create([Bind("Periodo", "NomeTurma", "NomeCurso, IdCurso")] Turma turma)
{
try
{
if (ModelState.IsValid)
{
_context.Add(turma);
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
}
catch (DbUpdateException)
{
ModelState.AddModelError("", "Não foi possível inserir os dados.");
}
return View(turma);
}
public async Task <IActionResult> DeleteConfirmed(long?id)
{
var instituicao = await instituicaoDAL.EliminarInstituicaoPorId((long)id);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> DeleteConfirmed(long?id)
{
var calendario = await calendarioDAL.EliminarCalendarioPorId((long)id);
TempData["Message"] = "A Data " + calendario.DataNome.ToUpper() + " foi removida";
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Create([Bind("Nome,Endereco")] Instituicao instituicao)
{
try
{
if (ModelState.IsValid)
{
_context.Add(instituicao);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
catch (DbUpdateException)
{
ModelState.AddModelError("", "Não foi possível inserir os dados.");
}
return(View(instituicao));
}
public async Task <IActionResult> DeleteConfirmed(long?id)
{
var projeto = await projetoDAL.EliminaProjetoPorId((long)id);
TempData["Message"] = "Projeto " + projeto.ProjetoNome.ToUpper() + " foi removida";
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> DeleteConfirmed(long?id)
{
var instituicao = await instituicaoDAL.EliminarInstituicaoPorId((long)id);
TempData["Message"] = "Instituição " + instituicao.Nome.ToUpper() + " foi removida";
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Create([Bind("Nome, Idade, Instrumento, Telefone, Sexo")] Musico musico)
{
try
{
if (ModelState.IsValid)
{
_context.Add(musico);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
catch (DbUpdateException ex)
{
ModelState.AddModelError(ex.Message, "Falha ao inserir");
}
return(View(musico));
}
public async Task <IActionResult> Create([Bind("Nome, numIntegrantes, Email, CatMusical, numAlbuns")] Banda banda)
{
try
{
if (ModelState.IsValid)
{
_context.Add(banda);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
catch (DbUpdateException ex)
{
ModelState.AddModelError(ex.Message, "Falha ao inserir");
}
return(View(banda));
}
public async Task <IActionResult> Create([Bind("Nome")] Departamento departamento)
{
try
{
if (ModelState.IsValid)
{
_context.Add(departamento);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
catch (DbUpdateException)
{
ModelState.TryAddModelError("", "Não possível inserir os dados");
}
return(View(departamento));
}
public async Task <IActionResult> Create([Bind("Id", "Nome")] UnidadeCurricular unidadecurricular)
{
try
{
if (ModelState.IsValid)
{
_context.Add(unidadecurricular);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
catch (DbUpdateException)
{
ModelState.AddModelError("", "Não foi possível inserir os dados.");
}
return(View(unidadecurricular));
}
public async Task <IActionResult> Create([Bind("Marca, Modelo, Cor, NumRodas, NumChassi")] Carro carro)
{
try
{
if (ModelState.IsValid)
{
_context.Add(carro);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
catch (DbUpdateException ex)
{
ModelState.AddModelError(ex.Message, "Falha ao inserir");
}
return(View(carro));
}
public async Task <IActionResult> DeleteConfirmed(long?id)
{
var frequencia = await _context.Frequencias.SingleOrDefaultAsync(f => f.FrequenciaID == id);
_context.Frequencias.Remove(frequencia);
TempData["Message"] = "A Presenca foi removida";
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}