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 Task <bool> Handle(RegistrarAlunoCommand message, CancellationToken cancellationToken)
{
if (!message.IsValid())
{
NotifyValidationErrors(message);
return(Task.FromResult(false));
}
var aluno = new Aluno(message.Id, message.IdUsuario, message.Nome, message.Matricula);
if (_alunoRepository.GetById(aluno.Id) != null)
{
Bus.RaiseEvent(new DomainNotification(message.MessageType, "Já existe um aluno com esse Email."));
return(Task.FromResult(false));
}
_alunoRepository.Add(aluno);
if (Commit())
{
Bus.RaiseEvent(new AlunoRegistradoEvent(aluno.Id, aluno.IdUsuario, aluno.Nome, aluno.Matricula));
}
return(Task.FromResult(true));
}
public IActionResult Post([FromBody] AlunoRequestDTO model)
{
var aluno = _mapper.Map <Aluno>(model);
_repository.Add(aluno);
_repository.SaveChanges();
return(Created(nameof(GetById), model));
}
public AlunoDTO SalvarAluno(AlunoDTO alunoDto)
{
var transaction = this.alunoRepository.GetTransaction();
try
{
Aluno aluno;
if (alunoDto.Id.HasValue)
{
aluno = alunoRepository.GetById(alunoDto.Id.Value);
aluno.Nome = alunoDto.Nome;
aluno.RG = alunoDto.RG;
aluno.CPF = alunoDto.CPF;
aluno.OrgaoEmissor = alunoDto.OrgaoEmissor;
aluno.Sexo = alunoDto.Sexo;
aluno.Naturalidade = alunoDto.Naturalidade;
aluno.Naturalidade = alunoDto.Naturalidade;
aluno.NomePai = alunoDto.NomePai;
aluno.NomeMae = alunoDto.NomeMae;
aluno.Endereco = alunoDto.Endereco;
aluno.CEP = alunoDto.CEP;
aluno.Bairro = alunoDto.Bairro;
aluno.Cidade = alunoDto.Cidade;
aluno.Complemento = alunoDto.Complemento;
aluno.DataMatricula = alunoDto.DataMatricula;
aluno.DataNascimento = alunoDto.DataNascimento;
aluno.DataValidade = alunoDto.DataValidade;
aluno.Telefone = alunoDto.Telefone;
aluno.Celular = alunoDto.Celular;
aluno.Email = alunoDto.Email;
aluno.CursoAnterior = alunoDto.CursoAnterior;
}
else
{
aluno = alunoDto.ToEntity();
aluno.TurmasAluno = new List <TurmaAluno>();
alunoRepository.Add(aluno);
}
alunoRepository.SaveChanges();
transaction.Commit();
transaction.Dispose();
return(new AlunoDTO(alunoRepository.GetById(aluno.Id)));
}
catch (Exception ex)
{
transaction.Rollback();
transaction.Dispose();
if (ex.InnerException.Message.Contains("cpf_UNIQUE"))
{
throw new BusinessException("Já existe um aluno com o CPF cadastrado.");
}
log.Error("Erro ao salvar aluno.", ex);
throw new BusinessException("Erro desconhecido ao salvar aluno.");
}
}
public IActionResult AddAluno(AlunoViewModels aluno)
{
var alunoMapper = _mapper.Map <Aluno>(aluno);
_alunoRepository.Add(alunoMapper);
return(View());
}
public async Task <SubmitResult <Aluno> > Cadastrar(Aluno entity)
{
var result = await new CadastrarAlunoValidator(_alunoRepository).ValidateAsync(entity);
if (result.IsValid)
{
_alunoRepository.Add(entity);
await _uow.CommitAsync();
}
return(new SubmitResult <Aluno>(await ObterPorId(entity.Id), result));
}
public IActionResult AdicionaUsuario([FromBody] Aluno aluno)
{
var list = _contextTurma.GetPorId(aluno.TurmaId);
if (list.IdTurma == null)
{
return(BadRequest("Essa turma não existe"));
}
_context.Add(aluno);
return(Ok());
}
public async Task <ActionResult> PostAluno(Aluno aluno)
{
try
{
_alunoRepository.Add(aluno);
await _alunoRepository.SaveChangeAsync();
return(CreatedAtAction("GetAluno", new { id = aluno.Id }, aluno));
}
catch (Exception ex)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, $"Ops! Houve um erro: { ex.Message }."));
}
}
public void Add(AlunoDTO alunoDto)
{
Turma turma = _turmaRepository.GetById(alunoDto.TurmaId);
Aluno aluno = new Aluno(alunoDto.Descricao.Split(':')[0], turma ?? new Turma(2007));
aluno.Endereco.Bairro = alunoDto.Bairro;
aluno.Endereco.Cep = alunoDto.Cep;
aluno.Endereco.Localidade = alunoDto.Localidade;
aluno.Endereco.Uf = alunoDto.Uf;
_alunoRepository.Add(aluno);
_unitOfWork.Commit();
}
public async Task <IActionResult> Post(Aluno Request)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(Request));
}
_repo.Add(Request);
if (await _repo.SaveChangesAsync())
{
return(Created($"/api/[controler]/Aluno{Request.Nome}", Request));
}
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status501NotImplemented, MSG.BancoDadosFalhou));
}
return(BadRequest());
}
public ValidationResult AdicionarNovoAluno(Aluno aluno)
{
var resultadoValidacao = new ValidationResult();
if (!aluno.IsValid)
{
resultadoValidacao.AdicionarErro(aluno.ResultadoValidacao);
return(resultadoValidacao);
}
var resultadoConsistencia = new AlunoEstaConsistenteParaCadastroValidation(_alunoRepository).Validar(aluno);
if (!resultadoConsistencia.IsValid)
{
resultadoValidacao.AdicionarErro(resultadoConsistencia);
return(resultadoValidacao);
}
_alunoRepository.Add(aluno);
return(resultadoValidacao);
}
public void AdicionarAluno(Aluno aluno)
{
repo.Add(aluno);
}