// GET: Alunos/Details/5
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
var model = await _context.Alunos.Include(a => a.Turma)
.FirstOrDefaultAsync(m => m.Id == id);
if (model == null)
{
return(NotFound());
}
var alunoViewModel = new AlunoViewModel {
Id = model.Id,
cc = model.cc,
contacto = model.contacto,
cp_1 = model.cp_1,
cp_2 = model.cp_2,
email = model.email,
genero = model.genero,
nome = model.nome,
id_turma = model.id_turma,
ImageUrl = model.ImageUrl,
localidade = model.localidade,
Turma = model.Turma,
morada = model.morada,
nif = model.nif,
};
return(View(alunoViewModel));
}
public ActionResult Cadastrar(AlunoViewModel alunoViewModel)
{
if (ModelState.IsValid)
{
var aluno = new Aluno()
{
Nome = alunoViewModel.Nome,
DataNascimento = alunoViewModel.DataNascimento,
Bolsa = alunoViewModel.Bolsa,
Desconto = alunoViewModel.Desconto,
GrupoId = alunoViewModel.GrupoId,
//Professor = alunoViewModel.Professores
};
_unit.AlunoRepository.Cadastrar(aluno);
_unit.Save();
return(RedirectToAction("Cadastrar", new { msg = "Aluno Cadastrado", tipoMsg = "alert alert-success" }));
}
else
{
alunoViewModel.ListaGrupo = ListarGrupos();
return(View(alunoViewModel));
}
//var viewModel = new AlunoViewModel()
//{
// TipoMensagem = "alert alert-success",
// Mensagem = "Cadastrado com sucesso!",
// ListaGrupo = ListarGrupos()
//};
}
private void InitializeApplication()
{
if (AlunoVM == null)
{
AlunoVM = new AlunoViewModel();
}
}
public async Task <IActionResult> Register(RegisterViewModel model)
{
if (!ModelState.IsValid)
{
NotifyModelStateErrors();
return(Response <RegisterViewModel>(model));
}
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email, EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, "CanWriteAlunoData");
var aluno = new AlunoViewModel()
{
Id = Guid.NewGuid(), IdUsuario = user.Id, Matricula = model.Matricula, Nome = model.Nome
};
_alunoAppService.Register(aluno);
return(Response <AlunoViewModel>(aluno));
}
AddIdentityErrors(result);
return(Response <AlunoViewModel>(new AlunoViewModel()
{
Matricula = model.Matricula, Nome = model.Nome
}));
}
public async Task <IActionResult> Atualizar(AlunoViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (!_alunoService.Buscar(p => p.Id == model.Id).Result.Any())
{
return(NotFound());
}
try
{
var aluno = _mapper.Map <Aluno>(model);
await _alunoService.Atualizar(aluno);
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
return(Accepted(nameof(ObterPorId), new { id = model.Id }));
}
public ActionResult Cadastrar(AlunoViewModel alunoViewModel)
{
if (ModelState.IsValid)
{
var aluno = new Aluno()
{
Nome = alunoViewModel.Nome,
DataNascimento = alunoViewModel.DataNascimento,
Desconto = alunoViewModel.Desconto,
Id = alunoViewModel.Id,
GrupoId = alunoViewModel.GrupoId,
Bolsa = alunoViewModel.Bolsa
};
_unit.AlunoRepository.Cadastrar(aluno);
_unit.Salvar();
var viewModel = new AlunoViewModel()
{
Mensagem = "Aluno cadastrado!!",
ListaGrupo = ListarGrupos()
};
return(RedirectToAction("Cadastrar", new { msg = "Aluno Cadastrado" }));
}
else
{
alunoViewModel.ListaGrupo = ListarGrupos();
return(View(alunoViewModel));
}
}
public ActionResult Cadastrar(AlunoViewModel alunoViewModel)
{
if (ModelState.IsValid)
{
var aluno = new Aluno()
{
Nome = alunoViewModel.Nome,
DataNascimento = alunoViewModel.DataNascimento,
Id = alunoViewModel.Id,
Bolsa = alunoViewModel.Bolsa,
Desconto = alunoViewModel.Desconto,
GrupoId = alunoViewModel.GrupoId
};
_unit.AlunoRepository.Cadastrar(aluno);
try
{
_unit.Salvar();
}
catch (Exception e)
{
alunoViewModel.Mensagem = "Erro - " + e.Message;//Mensagem de erro!
alunoViewModel.ListaGrupo = ListarGrupos();
return(View(alunoViewModel));
}
return(RedirectToAction("Cadastrar", new { msg = "Aluno Cadastrado" }));
}
else
{
alunoViewModel.ListaGrupo = ListarGrupos();
return(View(alunoViewModel));
}
}
public async Task <IActionResult> ExcluirTurma(Guid id, [Bind("Nome,DataNascimento,Cpf,Id,Cadastro,Atualizado, TurmaId")] AlunoViewModel alunoViewModel)
{
var command = new ExcluirAlunoTurmaCommand(id, alunoViewModel.TurmaId);
var response = await this._alunoService.DeleteTurma(command);
return(RedirectToAction("Details", new { id = id }));
}
// GET: Aluno/Details/5
public async Task <IActionResult> Details(Guid id)
{
if (id == null)
{
return(NotFound());
}
var tasks = new Task[3];
//var turmasDoAluno = await this._turmaService.Listar(new TurmaRequest(id, null));
//var turmasDisponivel = await this._turmaService.Listar(new TurmaRequest());
//var alunoViewModel = await this._alunoService.Detalhes(id);
var turmasDoAluno = new List <TurmaViewModel>();
var turmasDisponivel = new List <TurmaViewModel>();
var alunoViewModel = new AlunoViewModel();
tasks[0] = Task.Run(() => turmasDoAluno = this._turmaService.Listar(new TurmaRequest(id, null)).Result);
tasks[1] = Task.Run(() => turmasDisponivel = this._turmaService.Listar(new TurmaRequest()).Result);
tasks[2] = Task.Run(() => alunoViewModel = this._alunoService.Detalhes(id).Result);
await Task.WhenAll(tasks);
if (alunoViewModel == null)
{
return(NotFound());
}
alunoViewModel.Turmas = turmasDoAluno;
turmasDisponivel.RemoveAll(x => turmasDoAluno.Select(y => y.Id).Contains(x.Id));
ViewData["Turmas"] = new SelectList(turmasDisponivel, "Id", "Nome");
return(View(alunoViewModel));
}
public ActionResult Cadastro(AlunoViewModel alunoViewModel)
{
//automap
if (ModelState.IsValid)
{
var aluno = new Aluno()
{
Nome = alunoViewModel.Nome,
DataNascimento = alunoViewModel.DataNascimento,
Bolsa = alunoViewModel.Bolsa,
Desconto = alunoViewModel.Desconto,
GrupoId = alunoViewModel.GrupoId,
Id = alunoViewModel.Id,
};
_unit.AlunoRepository.Cadastrar(aluno);
_unit.Salvar();
return RedirectToAction("Cadastro", new { msg = "Aluno Cadastrado" });
}
else
{
alunoViewModel.ListaGrupo = ListarGrupos();
return View(alunoViewModel);
}
}
public NovoAlunoView()
{
vmAluno = new AlunoViewModel();
BindingContext = vmAluno;
InitializeComponent();
}
public async Task <bool> SalvarAluno(AlunoViewModel alunoVM)
{
try
{
Aluno aluno = Mapper.Map <Aluno>(alunoVM);
aluno.Sala = null;
aluno.Responsavel = null;
await BeginTransaction();
if (aluno.Id == 0)
{
await Task.Run(() => _alunoRepository.Add(aluno));
}
else
{
await Task.Run(() => _alunoRepository.Update(aluno));
}
await Commit();
return(true);
}
catch (Exception e)
{
throw e;
}
}
public async Task <ResponseApi <AlunoViewModel> > Editar(AlunoViewModel model)
{
var restRequest = new RestRequest("Aluno", DataFormat.Json);
restRequest.AddJsonBody(model);
return(await this._client.PutAsync <ResponseApi <AlunoViewModel> >(restRequest));
}
// GET: Alunos/Create
public IActionResult Create()
{
var aluno = new AlunoViewModel();
aluno.turmas = GetTurma();
return(View(aluno));
}
public ActionResult EditAluno(AlunoViewModel AlunoViewModel)
{
if (ModelState.IsValid)
{
ALUNO Aluno = db.ALUNO.Find(AlunoViewModel.Alunoid);
var Usuario = db.Usuario.Where(u => u.Email.ToUpper() == AlunoViewModel.Email.ToUpper()).FirstOrDefault();
if (Usuario != null && Aluno.Usuario.UsuarioId != Usuario.UsuarioId)
{
ModelState.AddModelError("email", "E-mail já cadastrado na base");
}
else
{
Aluno.NOME = AlunoViewModel.Nome;
Aluno.Usuario.Email = AlunoViewModel.Email;
Aluno.Usuario.HashSenha = GerarHash(AlunoViewModel.Senha);
Aluno.Usuario.FlagSenhaTemp = AlunoViewModel.SenhaTemporaria ? "S" : "N";
db.Entry(Aluno).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
return(View(AlunoViewModel));
}
public ActionResult Edit(int Id)
{
var aluno = _repoAluno.Listar().Where(m => m.Id == Id).FirstOrDefault();
var model = new AlunoViewModel(aluno);
return(PartialView("Edit", model));
}
public ActionResult Cadastrar(AlunoViewModel alunoVM)
{
//Se View Model valido
if (ModelState.IsValid)
{
//Objeto aluno recebe dados do viewmodel
Aluno a = new Aluno()
{
CursoId = alunoVM.CursoId,
DtNascimento = alunoVM.DtNascimento,
Nome = alunoVM.Nome,
Rm = alunoVM.Rm
};
//cadastrar Aluno
_unit.AlunoRepository.Cadastrar(a);
//Salvar
_unit.Save();
//redirecionar para Cadastrar
return(RedirectToAction("Cadastrar", new { msg = "Aluno cadastrado com sucesso" }));
}
else
{
//Seão for validado, devolve a lista de Cursos
alunoVM.Cursos = carregarCursos();
return(View(alunoVM));
}
}
private bool ValidateSave(AlunoViewModel formModel)
{
formModel.StatusOperation = true;
formModel.FieldsWithError.Clear();
var messageError = new List <String>();
if (String.IsNullOrEmpty(formModel.Nome))
{
messageError.Add(String.Format(GlobalizationController.GetInstance().GetString("The field '{0}' is required."), GlobalizationController.GetInstance().GetString("Name")));
formModel.FieldsWithError.Add(nameof(formModel.Nome));
}
if (!formModel.TurmaId.HasValue)
{
messageError.Add(String.Format(GlobalizationController.GetInstance().GetString("The field '{0}' is required."), GlobalizationController.GetInstance().GetString("Class")));
formModel.FieldsWithError.Add(nameof(formModel.TurmaId));
}
if (messageError.Count > 0)
{
formModel.StatusMessage = string.Join("<br>", messageError);
formModel.StatusOperation = false;
}
return(formModel.StatusOperation);
}
public AlunoViewModel Atualizar(AlunoViewModel alunoViewModel)
{
var aluno = Mapper.Map <Aluno>(alunoViewModel);
_alunoRepository.Atualizar(aluno);
return(alunoViewModel);
}
public ActionResult DeleteConfirmed(int id)
{
AlunoViewModel aluno = appService.ObterAlunoPorId(id);
appService.DeletarAluno(aluno);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> NovoAluno(AlunoViewModel alunoViewModel)
{
if (ModelState.IsValid)
{
alunoViewModel.IdDaPessoa = alunoViewModel.Pessoa.IdDaPessoa;
alunoViewModel.Role = "Aluno";
alunoViewModel.IdDoCurso = (int)TempData["CursoCoordenador"];
TempData.Keep();
var aluno = _mapper.Map <AlunoViewModel, Aluno>(alunoViewModel);
_alunoAppService.InserirAsync(aluno);
var user = new AppUser {
UserName = alunoViewModel.Pessoa.CpfDaPessoa, Email = alunoViewModel.Pessoa.EmailDaPessoa
};
var resultCreate = await _userManager.CreateAsync(user, alunoViewModel.Pessoa.CpfDaPessoa);
if (resultCreate.Succeeded)
{
var resultRole = await _userManager.AddToRoleAsync(user, alunoViewModel.Role);
if (resultRole.Succeeded)
{
return(Redirect("Alunos"));
}
}
}
return(View(alunoViewModel));
}
public AlunoViewPage()
{
var aluno = AlunoViewModel.GetAluno();
vmAluno = new AlunoViewModel(aluno);
BindingContext = vmAluno;
}
public ActionResult Novo()
{
var model = new AlunoViewModel();
model.Turmas = this.turmaBusiness.ListAll().ToList();
return(View(model));
}
private void InitializeVMs()
{
if (AlunoVM == null)
{
AlunoVM = new AlunoViewModel();
}
}
public ActionResult Editar(Aluno aluno)
{
AlunoViewModel viewModel = null;
if (ModelState.IsValid)
{
_unit.AlunoRepository.Alterar(aluno);
_unit.Save();
viewModel = new AlunoViewModel()
{
Mensagem = "Aluno atualizado!",
TipoMensagem = "alert alert-success",
ListaGrupo = ListarGrupos(),
ListaAluno = ListarAluno()
};
return(View("Listar", viewModel));
}
else
{
viewModel = new AlunoViewModel()
{
Mensagem = "Erro ao atualizar aluno.",
TipoMensagem = "alert alert-danger",
Nome = aluno.Nome,
DataNascimento = aluno.DataNascimento,
Bolsa = aluno.Bolsa,
Desconto = aluno.Desconto,
GrupoId = aluno.GrupoId,
ListaGrupo = ListarGrupos()
};
return(View(viewModel));
}
}
public void EditarAluno(AlunoViewModel alunoViewModel)
{
if (!_context.Aluno.Any(x => x.Id == alunoViewModel.AlunoId))
{
throw new NotFoundException("Id não encontrado");
}
try
{
Aluno aluno = new Aluno();
aluno.Id = alunoViewModel.AlunoId;
aluno.Nome = alunoViewModel.NomeAluno;
aluno.Cpf = alunoViewModel.Cpf;
aluno.Peso = alunoViewModel.Peso;
aluno.Altura = alunoViewModel.Altura;
aluno.ModalidadeId = alunoViewModel.IDModalidade;
_context.Aluno.Update(aluno);
_context.SaveChanges();
}
catch (DbConcurrencyException e)
{
throw new DbConcurrencyException(e.Message);
}
}
//(int id) para receber o id do view
public ActionResult Editar(int id)
{
//Debug.WriteLine("ID do aluno {0}", id);
var aluno = _unit.AlunoRepository.BuscarPorId(id);
//Debug.WriteLine(aluno.Nome);
var viewModel = new AlunoViewModel()
{
ListaGrupo = ListarGrupos(),
Nome = aluno.Nome,
Bolsa = aluno.Bolsa,
DataNascimento = aluno.DataNascimento,
Desconto = aluno.Desconto,
Id = aluno.Id,
GrupoId = aluno.GrupoId
};
//buscar o objeto (aluno) no banco
// var context = new PortalContext();
// var aluno = context.Aluno.Find(id);
//manda o aluno para a view
Debug.WriteLine(viewModel.DataNascimento);
return(View(viewModel));
}
public ActionResult CreateAluno(AlunoViewModel alunoViewModel)
{
if (ModelState.IsValid)
{
var Usuario = db.Usuario.Where(u => u.Email.ToUpper() == alunoViewModel.Email.ToUpper()).FirstOrDefault();
if (Usuario != null)
{
ModelState.AddModelError("email", "E-mail já cadastrado na base");
}
else
{
ALUNO aluno = new ALUNO()
{
NOME = alunoViewModel.Nome,
Usuario = new Usuario()
{
Email = alunoViewModel.Email,
HashSenha = GerarHash(alunoViewModel.Senha),
FlagSenhaTemp = alunoViewModel.SenhaTemporaria ? "S" : "N"
}
};
db.ALUNO.Add(aluno);
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
return(View(alunoViewModel));
}
public async Task <IActionResult> Atualizar(Guid id, AlunoViewModel alunoViewModel)
{
if (id != alunoViewModel.Id)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(PartialView("_Atualizar", alunoViewModel));
}
await _responsavelService.AtualizarDependente(alunoViewModel);
if (!OperacaoValida)
{
return(PartialView("_Atualizar", alunoViewModel));
}
TempData["Sucesso"] = "Dependente atualizado com sucesso!";
var url = Url.Action("ObterDependentes", new { responsavelId = alunoViewModel.ResponsavelId });
return(Json(new { success = true, url }));
}
public ActionResult Editar(int id)
{
var aluno = _unit.AlunoRepository.SearchById(id);
var viewModel = new AlunoViewModel
{
AlunoId = aluno.AlunoId,
Nome = aluno.Nome,
Cpf = aluno.Cpf,
DataNascimento = aluno.DataNascimento,
Especial = aluno.Especial,
Obs = aluno.Obs,
ModalidadeId = aluno.ModalidadeId,
EnderecoId = aluno.EnderecoId,
Logradouro = aluno.EnderecoCobranca.Logradouro,
Cep = aluno.EnderecoCobranca.Cep,
Cidade = aluno.EnderecoCobranca.Cidade,
Estado = aluno.EnderecoCobranca.Estado,
Celular = aluno.EnderecoCobranca.Celular,
Telefone = aluno.EnderecoCobranca.Telefone,
Modalidades = CarregarModalidades(),
Estados = CarregarEstados()
};
return(View(viewModel));
}