public void Add(Estudante item)
{
try
{
_estudanteService.Add(item);
_uow.SaveChanges();
}
catch (Exception ex)
{
throw ex;
}
}
static void Main(string[] args)
{
/*
* Fazer um programa que inicie com todos os dez quartos vazios, e depois
* leia uma quantidade N representando o número de estudantes que vão alugar quartos
* (N pode ser de 1 a 10). Em seguida, registre o aluguel dos N estudantes.
* Para cada registro de aluguel, informar o nome e email do estudante, bem como qual
* dos quartos ele escolheu (de 0 a 9). Suponha que seja escolhido um quarto vago.
* Ao final, seu programa deve imprimir um relatório de todas ocupações do pensionato,
* por ordem de quarto, conforme exemplo.
*/
Estudante[] vect = new Estudante[10];
Console.Write("Quantos quartos serão alugados?");
int n = int.Parse(Console.ReadLine());
for (int i = 1; i < n; i++)
{
Console.WriteLine();
Console.WriteLine($"Aluguel #{i}");
Console.Write("Nome: ");
string nome = Console.ReadLine();
Console.Write("E-mail: ");
string email = Console.ReadLine();
Console.Write("Quarto: ");
int qto = int.Parse(Console.ReadLine());
vect[qto] = new Estudante {
Nome = nome, Email = email
};
}
Console.WriteLine();
Console.WriteLine("Quartos Ocupados: ");
for (int i = 0; i < 10; i++)
{
if (vect[i] != null)
{
Console.WriteLine(i + ": " + vect[i]);
}
}
Console.ReadKey();
}
public void DeveRetornarErroQuandoTiverUmaAssinaturaValida()
{
var nome = new Nome("Thiago", "Chagas");
var email = new Email("*****@*****.**");
var doc = new Documento("05492256769", Dominio.Enums.ETipoDocumento.CPF);
var endereco = new Endereco("A", "21", "Niteroi", "23130110", "Fonseca", "Rio De Janeiro");
var estudante = new Estudante(nome, doc, email);
var assinatura = new Assinatura(null);
var pagamento = new PayPalPagamento("12345678", DateTime.Now, DateTime.Now.AddDays(5), 10, 10, "Thiago", doc, endereco, email);
assinatura.InserirPagamento(pagamento);
estudante.InserirAssinatura(assinatura);
estudante.InserirAssinatura(assinatura);
Assert.IsTrue(estudante.Invalid);
}
static void Main(string[] args)
{
Console.Write("Quantos quartos serão alugados? ");
int n = int.Parse(Console.ReadLine());
int nQuarto = 10;
Estudante[] vet = new Estudante[nQuarto];
for (int i = 0; i < n; i++)
{
Console.WriteLine("Aluguel #" + (i + 1) + ":");
Console.Write("Nome: ");
string nome = Console.ReadLine();
Console.Write("Email: ");
string email = Console.ReadLine();
Console.Write("Quarto: ");
int quarto = int.Parse(Console.ReadLine());
while (vet[quarto] != null)
{
Console.Write("Quarto ocupado, escolha outro: ");
quarto = int.Parse(Console.ReadLine());
}
vet[quarto] = new Estudante(nome, email);
}
Console.WriteLine();
Console.WriteLine("Quartos ocupados:");
for (int i = 0; i < nQuarto; i++)
{
if (vet[i] != null)
{
Console.WriteLine(i + ". " + vet[i]);
}
else
{
Console.WriteLine(i + ". Quarto Vazio");
}
}
}
public void Update(Estudante estudante)
{
if (estudante == null)
{
throw new ArgumentNullException("estudante");
}
if (estudante is IValidator)
{
((IValidator)estudante).Validate();
}
Estudante estudanteTemporario = Context.Estudantes.FirstOrDefault(c => c.Id == estudante.Id);
if (estudanteTemporario != null)
{
estudanteTemporario.Nome = estudante.Nome;
estudanteTemporario.SobreNome = estudante.SobreNome;
SaveChanges();
}
}
public ActionResult Edit(int id, FormCollection collection)
{
try
{
// TODO: Add update logic here
Estudante e = estudantes.First(es => es.id.Equals(id));
estudantes.Remove(e);
e.Nome = collection["Nome"];
e.Idade = int.Parse(collection["Idade"]);
e.Matricula = collection["Matricula"];
estudantes.Add(e);
setToSession(estudantes);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
// GET: Estudante
public async Task <IActionResult> Index(int?id, int?CursoID)
{
var viewModel = new EstudanteCurso();
viewModel.Estudantes = await _context.Estudante
.Include(i => i.Inscricoes)
.ThenInclude(i => i.Curso)
.OrderBy(i => i.NomeHeroi)
.ToListAsync();
if (id != null)
{
ViewData["EstudanteID"] = id.Value;
Estudante estudante = viewModel.Estudantes.Where(
i => i.ID == id.Value).Single();
viewModel.Cursos = estudante.Inscricoes.Select(s => s.Curso);
}
return(View(viewModel));
}
public async Task <IActionResult> Create([Bind("SobreNome,Nome,DataMatricula")] Estudante estudante)
{
try
{
if (ModelState.IsValid)
{
_context.Add(estudante);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
}
catch (DbUpdateException /* ex */)
{
//Logar o erro (descomente a variável ex e escreva um log
ModelState.AddModelError("", "Não foi possível salvar. " +
"Tente novamente, e se o problema persistir " +
"chame o suporte.");
}
return(View(estudante));
}
public ActionResult SalvarEstudante([FromBody] EstudanteDto dto)
{
var estudante = new Estudante(
dto.Id,
dto.Nome,
dto.Sobrenome,
dto.DataNascimento,
dto.Sexo,
dto.Email,
dto.Curso,
dto.AreaCurso,
dto.Semestre,
dto.Descricao,
dto.ValorMensal,
dto.ETipoUsuario
);
_estudantesCollection.InsertOne(estudante);
return(StatusCode(201, "Estudante adicionado com sucesso"));
}
public void Update(Estudante entity)
{
// Validação dos campos obrigatórios
string validText = "";
if (string.IsNullOrWhiteSpace(entity.Email))
{
validText += Environment.NewLine + " - Email é obrigatório";
}
if (string.IsNullOrWhiteSpace(entity.Nome))
{
validText += Environment.NewLine + " - Nome é obrigatório";
}
if (!string.IsNullOrWhiteSpace(validText))
{
throw new Exception($"Erro de validação: {validText}");
}
_estudanteRepository.Update(entity);
}
public bool Add(Estudante estudante)
{
bool addResult = false;
if (estudante == null)
{
return(addResult);
}
int index = estudantes.FindIndex(s => s.Id == estudante.Id);
if (index == -1)
{
estudantes.Add(estudante);
addResult = true;
return(addResult);
}
else
{
return(addResult);
}
}
public ActionResult Create(Estudante estudante)
{
if (ModelState.IsValid)
{
if (estudantes.Count == 0)
{
estudante.id = 1;
}
else
{
estudante.id = estudantes[estudantes.Count - 1].id + 1;
}
estudantes.Add(estudante);
setToSession(estudantes);
return(RedirectToAction("Index"));
}
else
{
return(View(estudante));
}
}
public async Task <EstudanteViewModel> UpdateAsync(EstudanteViewModel vm)
{
try
{
Estudante objeto = _unitOfWork.GenericRepository <Estudante>().GetByID(vm.Id);
objeto.Nome = vm.Nome;
objeto.UsuarioNome = vm.UsuarioNome;
objeto.ImagemNomeArquivo = vm.ImagemNomeArquivo != null ?
vm.ImagemNomeArquivo : objeto.ImagemNomeArquivo;
objeto.CVNomeArquivo = vm.CVNomeArquivo != null ?
vm.CVNomeArquivo : objeto.CVNomeArquivo;
objeto.Contato = vm.Contato;
await _unitOfWork.GenericRepository <Estudante>().UpdateAsync(objeto);
_unitOfWork.Save();
}
catch (Exception)
{
throw;
}
return(vm);
}
public static void Main()
{
Estudante e = new Estudante();
e.Nome = "Fabio Galuppo";
e.Idade = 18;
e.ID = "ID_5678";
e.Email = "*****@*****.**";
Pessoa p = e; //Polimorfismo: p assume a interface Pessoa do objeto e
p.Falar("C# é legal");
Pessoa p2, p3;
p2 = p.Duplicar(p);
p.Falar("Desenvolvendo com C#");
p3 = p.Duplicar(e); //Polimorfismo: p assume a interface Pessoa do objeto e
p.Falar("OO é suportada pelo C#");
//Cast permitido pois o objeto p foi originado de um cast do objeto e
Estudante e2 = (Estudante)p;
Console.WriteLine("{0} {1} {2} {3}", e2.Nome, e2.Idade, e2.ID, e2.Email);
Pessoa p4 = new Pessoa();
p4.Nome = "Wallace Santos";
p4.Idade = 22;
//Cast não permitido pois a classe p4 não suporta todos os requisitos de e3
Estudante e3 = (Estudante)p4;
Console.WriteLine("{0} {1}", e3.Nome, e3.Idade);
}
public async Task <IActionResult> Editar(int?id, [Bind("Id, EnrollmentDate, Nome, Sobrenome")] Estudante estudante)
{
if (id != estudante.Id)
{
return(NotFound(new { message = "Id do estudante não esta na base de dados!" }));
}
if (ModelState.IsValid)
{
try
{
Contexto.Update(estudante);
await Contexto.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch (DbUpdateException)
{
ModelState.AddModelError("", "Nao foi possivel salvar os dados");
}
}
return(View(estudante));
}
public ActionResult Editar(string id, Estudante estudante)
{
try
{
var filter = Builders <Estudante> .Filter.Eq("_id", ObjectId.Parse(id));
var novoEstudante = Builders <Estudante> .Update.Set("nome", estudante.Nome)
.Set("curso", estudante.Curso)
.Set("user", estudante.User)
.Set("password", estudante.Password)
.Set("rm", estudante.Rm)
.Set("dataMatricula", estudante.DataMatricula)
.Set("valorMensalidade", estudante.ValorMensalidade);
var result = _estudanteCollection.UpdateOne(filter, novoEstudante);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(View());
}
}
public void Executar()
{
Titulo.Exibir("ORDER_BY");
List <Estudante> lista = Estudante.ObterEstudantes();
#region Linq
Titulo.ExibirSub("LINQ");
var ordenar = lista
.OrderBy(x => x.Sexo)
.ThenByDescending(x => x.Materias.Count)
.ThenBy(x => x.Nome);
foreach (var item in ordenar)
{
Console.WriteLine($"{item.Nome} \t {item.Sexo} \t {item.Materias.Count}");
}
#endregion
#region Sql
Titulo.ExibirSub("SQL");
var sql = (from e in lista
orderby e.Sexo, e.Materias.Count descending
select e).ThenBy(x => x.Nome);
foreach (var item in sql)
{
Console.WriteLine($"{item.Nome} \t {item.Sexo} \t {item.Materias.Count}");
}
#endregion
Console.ReadKey();
}
public static void ExecutarExercicio()
{
using (var ctx = new EscolaContext())
{
Estudante stud = new Estudante()
{
CPF = 999999, Nome = "Novo Aluno", DataNascimento = DateTime.Now
};
stud.Nota = new Nota()
{
Descricao = "A+"
};
ctx.Alunos.Add(stud);
ctx.SaveChanges();
var students = from s in ctx.Alunos select s;
foreach (Estudante s in students)
{
Console.WriteLine(s.Nome);
}
}
}
public static void Main()
{
Pessoa p = new Pessoa();
p.Nome = "Fabio Galuppo";
p.Idade = 18;
Pessoa pclone = (Pessoa)p.Clone();
p.Falar("C# é legal");
pclone.Falar("C# suporta Aspectos");
Estudante e = new Estudante();
e.Nome = "Vanclei Matheus";
e.Idade = 20;
e.ID = "EST_1234";
e.Email = "*****@*****.**";
Estudante eclone = (Estudante)e.Clone();
e.Estudar("C#");
eclone.Estudar("Composição");
}
public void CriarAssinatura(Estudante aluno)
{
}
public Aluguel(short quarto, Estudante estudante)
{
_quarto = quarto;
_estudante = estudante;
}
public Aluguel(short aluguel, string nome, string email)
{
_quarto = aluguel;
_estudante = new Estudante(nome, email);
}
public void Add(Estudante item)
{
_estudanteRepository.Add(item);
}
public void remove(Estudante estudante)
{
db.Estudantes.Attach(estudante);
db.Estudantes.Remove(estudante);
db.SaveChanges();
}
public void Update(Estudante item)
{
_estudanteRepository.Update(item);
}
public void Remover(Estudante entity)
{
_estudanteRepository.Remover(entity);
}
public Estudante Adicionar(Estudante entity)
{
return(_estudanteRepository.Adicionar(entity));
}
public void CriarAssinatura(Estudante estudante)
{
throw new System.NotImplementedException();
}
public Estudante detalhe(int?id)
{
Estudante estudante = db.Estudantes.Include(i => i.inscricoes).SingleOrDefault(x => x.id == id);
return(estudante);
}
public void Atualizar(Estudante entity)
{
_estudanteRepository.Atualizar(entity);
}
public void adiciona(Estudante estudante)
{
db.Estudantes.Add(estudante);
db.SaveChanges();
}
public static void Initialize(EscolaContexto context)
{
context.Database.EnsureCreated();
// procura por qualquer estudante
if (context.Estudantes.Any())
{
return; //O banco foi inicializado
}
var estudantes = new Estudante[]
{
new Estudante {
Nome = "Carlos", SobreNome = "Silveira", DataMatricula = DateTime.Parse("2015-09-01")
},
new Estudante {
Nome = "Maria", SobreNome = "Alonso", DataMatricula = DateTime.Parse("2012-09-01")
},
new Estudante {
Nome = "Bianca", SobreNome = "Almeida", DataMatricula = DateTime.Parse("2013-09-01")
},
new Estudante {
Nome = "Jose Carlos", SobreNome = "Siqueira", DataMatricula = DateTime.Parse("2012-09-01")
},
new Estudante {
Nome = "Yuri", SobreNome = "Silva", DataMatricula = DateTime.Parse("2012-09-01")
},
new Estudante {
Nome = "Mario", SobreNome = "Domingues", DataMatricula = DateTime.Parse("2011-09-01")
},
new Estudante {
Nome = "Laura", SobreNome = "Santos", DataMatricula = DateTime.Parse("2013-09-01")
},
new Estudante {
Nome = "Jefferson", SobreNome = "Bueno", DataMatricula = DateTime.Parse("2015-09-01")
}
};
foreach (Estudante s in estudantes)
{
context.Estudantes.Add(s);
}
context.SaveChanges();
var cursos = new Curso[]
{
new Curso {
CursoID = 1050, Titulo = "Quimica", Creditos = 3,
},
new Curso {
CursoID = 4022, Titulo = "Economia", Creditos = 3,
},
new Curso {
CursoID = 4041, Titulo = "Economia", Creditos = 3,
},
new Curso {
CursoID = 1045, Titulo = "Cálculo", Creditos = 4,
},
new Curso {
CursoID = 3141, Titulo = "Trigonometria", Creditos = 4,
},
new Curso {
CursoID = 2021, Titulo = "Música", Creditos = 3,
},
new Curso {
CursoID = 2042, Titulo = "Literatura", Creditos = 4,
}
};
foreach (Curso c in cursos)
{
context.Cursos.Add(c);
}
context.SaveChanges();
var matriculas = new Matricula[]
{
new Matricula {
EstudanteID = 1, CursoID = 1050, Nota = Nota.A
},
new Matricula {
EstudanteID = 1, CursoID = 4022, Nota = Nota.C
},
new Matricula {
EstudanteID = 1, CursoID = 4041, Nota = Nota.B
},
new Matricula {
EstudanteID = 2, CursoID = 1045, Nota = Nota.B
},
new Matricula {
EstudanteID = 2, CursoID = 3141, Nota = Nota.F
},
new Matricula {
EstudanteID = 2, CursoID = 2021, Nota = Nota.F
},
new Matricula {
EstudanteID = 3, CursoID = 1050
},
new Matricula {
EstudanteID = 4, CursoID = 1050,
},
new Matricula {
EstudanteID = 4, CursoID = 4022, Nota = Nota.F
},
new Matricula {
EstudanteID = 5, CursoID = 4041, Nota = Nota.C
},
new Matricula {
EstudanteID = 6, CursoID = 1045
},
new Matricula {
EstudanteID = 7, CursoID = 3141, Nota = Nota.A
},
};
foreach (Matricula e in matriculas)
{
context.Matriculas.Add(e);
}
context.SaveChanges();
}
public void atualiza(Estudante estudante)
{
db.Entry(estudante).State = EntityState.Modified;
db.SaveChanges();
}
