private void btnGravar_Click(object sender, RoutedEventArgs e)
{
i = new Instrutor();
i.Nome = txtNome.Text;
i.Sobrenome = txtSobrenome.Text;
i.CPF = txtCPF.Text;
i.Celular = txtCelular.Text;
i.DtNasc = DtNasc.Text;
i.Telefone = txtTelefone.Text;
i.Email = txtEmail.Text;
i.Endereco = txtEndereco.Text;
if (InstrutorDAO.AdicionarInstrutor(i))
{
MessageBox.Show("Gravado com sucesso!", "Cadastro de Instrutor",
MessageBoxButton.OK, MessageBoxImage.Information);
}
else
{
MessageBox.Show("Não foi possível gravar!", "Cadastro de Instrutor",
MessageBoxButton.OK, MessageBoxImage.Error);
}
txtNome.Clear();
txtSobrenome.Clear();
txtCPF.Clear();
DtNasc.Text = null;
txtCelular.Clear();
txtTelefone.Clear();
txtEmail.Clear();
txtEndereco.Clear();
}
private void cmbInstrutor_Loaded(object sender, RoutedEventArgs e)
{
var lista = InstrutorDAO.ReturnLista();
Instrutor instrutor = new Instrutor();
cmbInstrutor.ItemsSource = lista;
}
public async Task <IActionResult> Create([Bind("Nome,Sobrenome,Contratacao, Escritorio")] Instrutor instrutor, string[] cursosSelecionados)
{
if (cursosSelecionados != null)
{
instrutor.CursosInstrutor = new List <CursoInstrutor>();
foreach (var curso in cursosSelecionados)
{
var cursoToAdd = new CursoInstrutor {
InstrutorID = instrutor.InstrutorID, CursoID = int.Parse(curso)
};
instrutor.CursosInstrutor.Add(cursoToAdd);
}
}
if (ModelState.IsValid)
{
_context.Add(instrutor);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
CarregarCursosAtribuidos(instrutor);
return(View(instrutor));
}
private void btnBuscarCPFInstrutor_Click(object sender, RoutedEventArgs e)
{
i = new Instrutor();
if (!string.IsNullOrEmpty(txtBuscarInstrutor.Text))
{
i.CPF = txtBuscarInstrutor.Text;
i = InstrutorDAO.VerificaInstrutorPorCPF(i);
if (i != null)
{
txtNome.Text = i.Nome;
txtSobrenome.Text = i.Sobrenome;
txtCPF.Text = i.CPF;
txtCelular.Text = i.Celular;
DtNasc.Text = i.DtNasc;
txtTelefone.Text = i.Telefone;
txtEndereco.Text = i.Endereco;
txtEmail.Text = i.Email;
HabilitarBotoes();
}
else
{
MessageBox.Show("Intrutor não encontrado!", "Busca Instrutor",
MessageBoxButton.OK, MessageBoxImage.Information);
}
}
else
{
MessageBox.Show("Favor preencher o campo da busca", "Busca Instrutor",
MessageBoxButton.OK, MessageBoxImage.Information);
}
}
public Instrutor PesquisarPorCodigo(int IdInstrutor)
{
try
{
AbrirConexao();
Cmd = new SqlCommand("select * from tb_instrutor where IdInstrutor =@idInstrutor", Con);
Cmd.Parameters.AddWithValue("@idInstrutor", IdInstrutor);
Dr = Cmd.ExecuteReader(); //execução da leitura
Instrutor i = null; // Ponteiro
if (Dr.Read())
{
i = new Instrutor();
i.IdInstrutor = Convert.ToInt32(Dr["IdInstrutor"]);
i.NomeInstrutor = Convert.ToString(Dr["NomeInstrutor"]);
i.EmailInstrutor = Convert.ToString(Dr["EmailInstrutor"]);
i.Login = Convert.ToString(Dr["Login"]);
}
return(i);
}
catch (Exception ex)
{
throw new Exception("Erro ao obter Instrutor pelo Código" + ex.Message);
}
finally
{
FecharConexao();
}
}
private void UpdateInstructorCourses(string[] selectedCourses, Instrutor instructorToUpdate)
{
if (selectedCourses == null)
{
instructorToUpdate.Cursos = new List <Curso>();
return;
}
var selectedCoursesHS = new HashSet <string>(selectedCourses);
var instructorCourses = new HashSet <int>
(instructorToUpdate.Cursos.Select(c => c.CursoID));
foreach (var course in db.Cursos)
{
if (selectedCoursesHS.Contains(course.CursoID.ToString()))
{
if (!instructorCourses.Contains(course.CursoID))
{
instructorToUpdate.Cursos.Add(course);
}
}
else
{
if (instructorCourses.Contains(course.CursoID))
{
instructorToUpdate.Cursos.Remove(course);
}
}
}
}
private void AtualizarCursosInstrutor(string[] cursosSelecionados, Instrutor instrutorAtualizado)
{
if (cursosSelecionados == null)
{
instrutorAtualizado.CursoInstrutores = new List <CursoInstrutor>();
return;
}
var cursosSelct = new HashSet <string>(cursosSelecionados);
var cursosInstrutores = new HashSet <int>(instrutorAtualizado.CursoInstrutores.Select(c => c.Curso.CursoId));
foreach (var curso in Contexto.Cursos)
{
if (cursosSelct.Contains(curso.CursoId.ToString()))
{
if (!cursosInstrutores.Contains(curso.CursoId))
{
instrutorAtualizado.CursoInstrutores.Add(new CursoInstrutor {
InstrutorId = instrutorAtualizado.Id, CursoId = curso.CursoId
});
}
}
else
{
if (cursosInstrutores.Contains(curso.CursoId))
{
CursoInstrutor cursoRemover = instrutorAtualizado.CursoInstrutores.FirstOrDefault(x => x.CursoId == curso.CursoId);
Contexto.Remove(cursoRemover);
}
}
}
}
private void AtualizarCursosInstrutor(string[] cursosSelecionados, Instrutor instrutorToUpdate)
{
if (cursosSelecionados == null)
{
instrutorToUpdate.CursosInstrutor = new List <CursoInstrutor>();
return;
}
var cursosSelecionadosHS = new HashSet <string>(cursosSelecionados);
var CursosInstrutor = new HashSet <int>
(instrutorToUpdate.CursosInstrutor.Select(c => c.Curso.CursoID));
foreach (var curso in _context.Curso)
{
if (cursosSelecionadosHS.Contains(curso.CursoID.ToString()))
{
if (!CursosInstrutor.Contains(curso.CursoID))
{
instrutorToUpdate.CursosInstrutor.Add(new CursoInstrutor
{
InstrutorID = instrutorToUpdate.InstrutorID,
CursoID = curso.CursoID
});
}
}
else
{
if (CursosInstrutor.Contains(curso.CursoID))
{
CursoInstrutor cursoToRemove = instrutorToUpdate.CursosInstrutor.FirstOrDefault(i => i.CursoID == curso.CursoID);
_context.Remove(cursoToRemove);
}
}
}
}
public static void RemoverInstrutor(SortedSet <Aluno> alunos, SortedSet <Instrutor> instrutores, SortedSet <Curso> cursos)
{
Console.Write("Digite a id do instrutor: ");
int id = int.Parse(Console.ReadLine());
bool removido = false;
Instrutor remInstrutor = new Instrutor();
foreach (Instrutor instrutor in instrutores)
{
if (id == instrutor.Id)
{
remInstrutor = instrutor;
removido = true;
}
}
if (removido)
{
Console.WriteLine($"Aluno {remInstrutor.Id}, {remInstrutor.Nome} removido.");
foreach (Curso curso in cursos)
{
if (curso.Instrutor == remInstrutor)
{
curso.SetInstrutor(null);
}
}
instrutores.Remove(remInstrutor);
}
else
{
Console.WriteLine("Id inexistente.");
}
}
// GET: Instrutores
public async Task <IActionResult> Index(int?instrutorID, int?cursoID)
{
//return View(await _context.Instrutor.ToListAsync());
var viewModel = new InstrutorIndexData();
viewModel.Instrutores = await _context.Instrutor
.Include(i => i.Escritorio)
.Include(i => i.CursosInstrutor)
.ThenInclude(i => i.Curso)
.ThenInclude(i => i.Matriculas)
.ThenInclude(i => i.Aluno)
.Include(i => i.CursosInstrutor)
.ThenInclude(i => i.Curso)
.ThenInclude(i => i.Departamento)
.AsNoTracking()
.OrderBy(i => i.Sobrenome)
.ToListAsync();
if (instrutorID != null)
{
ViewData["InstrutorID"] = instrutorID.Value;
Instrutor instrutor = viewModel.Instrutores.Where(
i => i.InstrutorID == instrutorID.Value).Single();
viewModel.Cursos = instrutor.CursosInstrutor.Select(s => s.Curso);
}
if (cursoID != null)
{
ViewData["CursoID"] = cursoID.Value;
viewModel.Matriculas = viewModel.Cursos.Where(
x => x.CursoID == cursoID).Single().Matriculas;
}
return(View(viewModel));
}
public ActionResult Incluir([DataSourceRequest] DataSourceRequest request, InstrutorViewModel item)
{
if (ModelState.IsValid)
{
try
{
Instrutor dados = Mapper.Map <Instrutor>(item);
_repositorio.Inserir(dados);
_contexto.SaveChanges();
item.PessoaId = dados.PessoaId;
}
catch (Exception erro)
{
if (erro.InnerException.InnerException.Message.Contains("IdxNome"))
{
ModelState.AddModelError("", "O nome já foi incluído.");
}
_contexto.Rollback();
return(Json(ModelState.ToDataSourceResult()));
}
}
return(Json(new[] { item }.ToDataSourceResult(request)));
}
public Instrutor ValidarLogin(string login, string senha)
{
try
{
AbrirConexao();
Cmd = new SqlCommand("select * from tb_instrutor where Login=@login and Senha=@senha", Con);
Cmd.Parameters.AddWithValue("@login", login);
Cmd.Parameters.AddWithValue("@senha", senha);
Dr = Cmd.ExecuteReader(); //execução da leitura
Instrutor i = null; // Ponteiro
if (Dr.Read())
{
i = new Instrutor();
Cmd.Parameters.AddWithValue("@login", i.Login);
Cmd.Parameters.AddWithValue("@senha", i.Senha);
}
return(i);
}
catch (Exception ex)
{
throw new Exception("Erro ao obter o Instrutor pelo ID" + ex.Message);
}
finally
{
FecharConexao();
}
}
public async Task <IActionResult> Edit(int id, [Bind("InstrutorID,Nome,Sobrenome,Contratacao")] Instrutor instrutor)
{
if (id != instrutor.InstrutorID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(instrutor);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!InstrutorExists(instrutor.InstrutorID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(instrutor));
}
public Instrutor PesquisarPorCodigo(int IdInstrutor)
{
try
{
AbrirConexao();
Cmd = new SqlCommand("select * from tb_instrutor where IdInstrutor =@idinstrutor", Con);
Cmd.Parameters.AddWithValue("@idinstrutor", IdInstrutor);
Dr = Cmd.ExecuteReader(); //execução da leitura
Instrutor i = null; // Ponteiro
if (Dr.Read())
{
i = new Instrutor();
Cmd.Parameters.AddWithValue("@idinstrutor", i.IdInstrutor);
Cmd.Parameters.AddWithValue("@nome", i.Nome);
Cmd.Parameters.AddWithValue("@login", i.Login);
Cmd.Parameters.AddWithValue("@senha", i.Senha);
Cmd.Parameters.AddWithValue("@email", i.Email);
}
return(i);
}
catch (Exception ex)
{
throw new Exception("Erro ao obter o Instrutor pelo ID" + ex.Message);
}
finally
{
FecharConexao();
}
}
// GET: Instrutores/Create
public IActionResult Create()
{
var instrutor = new Instrutor();
instrutor.CursosInstrutor = new List <CursoInstrutor>();
CarregarCursosAtribuidos(instrutor);
return(View());
}
public static void NovoInstrutor(SortedSet <Aluno> alunos, SortedSet <Instrutor> instrutores, SortedSet <Curso> cursos)
{
Console.Write("Digite a id do instrutor: ");
int id = int.Parse(Console.ReadLine());
bool novo = true;
foreach (Instrutor instrutor in instrutores)
{
if (id == instrutor.Id)
{
Console.WriteLine($"Já existe um instrutor com id {id}");
Console.ReadLine();
novo = false;
}
}
if (novo)
{
Console.Write("Nome do instrutor: ");
string nome = Console.ReadLine();
Instrutor instrutor = new Instrutor(id, nome);
instrutores.Add(instrutor);
char resposta = 's';
while (resposta == 's')
{
Console.Write("Deseja inscrever o instrutor em algum curso (s/n)? ");
resposta = Console.ReadLine()[0];
if (resposta == 's')
{
Console.WriteLine("Cursos disponíveis");
foreach (Curso curso in cursos)
{
Console.WriteLine($"\t{curso.Id}, {curso.Nome}");
}
Console.Write("Digite a id do curso desejado: ");
int idMatricula = int.Parse(Console.ReadLine());
bool matricula = false;
foreach (Curso curso in cursos)
{
if (idMatricula == curso.Id)
{
instrutor.AddCursoMinistrado(curso);
curso.SetInstrutor(instrutor);
matricula = true;
}
}
if (!matricula)
{
Console.WriteLine("Curso inexistente");
}
else
{
instrutor.ConsultaInstrutor();
}
}
}
}
}
public ActionResult Create()
{
var instructor = new Instrutor
{
Cursos = new List <Curso>()
};
PopulateAssignedCourseData(instructor);
return(View());
}
public IActionResult Criar()
{
var instrutor = new Instrutor
{
CursoInstrutores = new List <CursoInstrutor>()
};
DataAssinaturaCurso(instrutor);
return(View());
}
public async Task <IActionResult> Create([Bind("InstrutorID,Nome,Sobrenome,Contratacao")] Instrutor instrutor)
{
if (ModelState.IsValid)
{
_context.Add(instrutor);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(instrutor));
}
//remove cadastro do Instrutor
public static bool RemoverInstrutor(Instrutor i)
{
try
{
ctx.Instrutor.Remove(i);
ctx.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
private void CarregarDadosUsuario()
{
int IdInstrutor = Convert.ToInt32(txtIdUsuario.Text);
InstrutorDAL iDAL = new InstrutorDAL();
Instrutor i = iDAL.PesquisarPorCodigo(IdInstrutor);
if (i != null)
{
txtNomeInstrutor.Text = i.NomeInstrutor;
txtEmailInstrutor.Text = i.EmailInstrutor;
txtLogin.Text = i.Login;
}
}
//altera os dados do Instrutor
public static bool AlterarInstrutor(Instrutor i)
{
try
{
ctx.Entry(i).State = System.Data.Entity.EntityState.Modified;
ctx.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
public bool Salvar(Instrutor instrutor)
{
using (var cnn = new MySqlConnection(Settings.Default.MySqlConnectionSetting))
{
if (instrutor.IdInstrutor > 0)
{
return(cnn.Execute("update instrutor set instrutor = @nome, telefone = @telefone," +
"dataupd=@dataExc, idusuarioupd=@idusuario where idinstrutor = @idinstrutor", instrutor) > 0);
}
return(cnn.Execute("insert into instrutor (instrutor, telefone, datainc, idusuarioinc) " +
"values (@nome, @telefone, @dataexc, @idusuario)", instrutor) > 0);
}
}
// GET: Instructor/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Instrutor instructor = db.Instrutores.Find(id);
if (instructor == null)
{
return(HttpNotFound());
}
return(View(instructor));
}
private void DataAssinaturaCurso(Instrutor instrutorAtualizado)
{
var todosCursos = Contexto.Cursos;
var cursosIntrutores = new HashSet <int>(instrutorAtualizado.CursoInstrutores.Select(c => c.CursoId));
var viewModel = new List <DataAssinaturaCurso>();
foreach (var curso in todosCursos)
{
viewModel.Add(new DataAssinaturaCurso
{
CursoId = curso.CursoId,
Titulo = curso.Titulo,
Assinatura = cursosIntrutores.Contains(curso.CursoId)
});
}
ViewData["Cursos"] = viewModel;
}
private void PopulateAssignedCourseData(Instrutor instructor)
{
var allCourses = db.Cursos;
var instructorCourses = new HashSet <int>(instructor.Cursos.Select(c => c.CursoID));
var viewModel = new List <AssignedCourseData>();
foreach (var course in allCourses)
{
viewModel.Add(new AssignedCourseData
{
CourseID = course.CursoID,
Title = course.Titulo,
Assigned = instructorCourses.Contains(course.CursoID)
});
}
ViewBag.Courses = viewModel;
}
private void CarregarCursosAtribuidos(Instrutor instrutor)
{
var todosCursos = _context.Curso;
var instrutorCursos = new HashSet <int?>(instrutor.CursosInstrutor.Select(c => c.CursoID));
var viewModel = new List <InstrutorCursoData>();
foreach (var curso in todosCursos)
{
viewModel.Add(new InstrutorCursoData
{
CursoID = curso.CursoID,
Titulo = curso.Titulo,
Atribuido = instrutorCursos.Contains(curso.CursoID)
});
}
ViewData["Cursos"] = viewModel;
}
static void ExemploDeTabelaPorHeranca()
{
using (var db = new ApplicationContext())
{
db.Database.EnsureDeleted();
db.Database.EnsureCreated();
var pessoa = new Pessoa {
Nome = "Fulano de Tal"
};
var instrutor = new Instrutor {
Nome = "Rafael Almeida", Tecnologia = ".NET", Desde = DateTime.Now
};
var aluno = new Aluno {
Nome = "Maria Thysbe", Idade = 31, DataContrato = DateTime.Now.AddDays(-1)
};
db.AddRange(pessoa, instrutor, aluno);
db.SaveChanges();
var pessoas = db.Pessoas.AsNoTracking().ToArray();
var instrutores = db.Instrutores.AsNoTracking().ToArray();
// var alunos = db.Alunos.AsNoTracking().ToArray();
var alunos = db.Pessoas.OfType <Aluno>().AsNoTracking().ToArray(); // Sem o uso de DbSet atraves do OffType
Console.WriteLine("----- Pessoas -----");
foreach (var pessoaItem in pessoas)
{
Console.WriteLine($"{pessoaItem.Id} -> {pessoaItem.Nome}");
}
Console.WriteLine("----- Instrutores -----");
foreach (var instrutorItem in instrutores)
{
Console.WriteLine($"Id: {instrutorItem.Id} -> {instrutorItem.Nome}, Tecnologia: {instrutorItem.Tecnologia}, Desde: {instrutorItem.Desde}");
}
Console.WriteLine("----- Alunos -----");
foreach (var alunoItem in alunos)
{
Console.WriteLine($"Id: {alunoItem.Id} -> {alunoItem.Nome}, Idade: {alunoItem.Idade}, Data do Contrato: {alunoItem.DataContrato}");
}
}
}
protected void CadastrarInstrutor(object sender, EventArgs e)
{
Instrutor i = new Instrutor();
i.NomeInstrutor = txtNome.Text;
i.Login = txtUsuario.Text;
i.EmailInstrutor = txtEmail.Text;
i.Senha = txtSenha.Text;
InstrutorDAL iDAL = new InstrutorDAL();
iDAL.Gravar(i);
lblMensagem.Text = "Cadastro de " + i.NomeInstrutor + " realizado com sucesso. Faça login agora mesmo.";
txtNome.Text = string.Empty;
txtUsuario.Text = string.Empty;
txtEmail.Text = string.Empty;
txtSenha.Text = string.Empty;
}
protected void btnAlterarInstrutor(object sender, EventArgs e)
{
try
{
Instrutor i = new Instrutor();
i.IdInstrutor = Convert.ToInt32(txtIdUsuario.Text);
i.NomeInstrutor = Convert.ToString(txtNomeInstrutor.Text);
i.EmailInstrutor = Convert.ToString(txtEmailInstrutor.Text);
i.Login = Convert.ToString(txtLogin.Text);
InstrutorDAL iDAL = new InstrutorDAL();
iDAL.Atualizar(i);
lblMensagem.Text = "Usuário " + i.Login + " atualizado com sucesso.";
}
catch (Exception)
{
throw;
}
}
