public async Task <Termo> AdicionarAsync(Termo termo)
{
validador.Validar(termo, TermoValidador.AO_ADICIONAR);
await comandoRepositorio.AdicionarAsync(termo);
return(termo);
}
public async Task <Resposta <Usuario> > Handle(CriarUsuarioComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <Usuario>(erros));
}
var usuario = new Usuario
{
Ativo = request.Ativo,
Email = request.Email,
Foto = request.Foto,
Login = request.Login,
Nome = request.Nome,
PerfilCodigo = request.PerfilCodigo,
Telefone = request.Telefone,
CursoCodigo = request.CursoCodigo
};
string senha = SenhaHelper.Gerar();
usuario.Senha = senha.ToMD5();
await EnviarEmailConfirmacaoCadastro(usuario.Email, usuario.Login, senha);
var usuarioCadastrado = await _repositorio.Criar(usuario);
return(new Resposta <Usuario>(usuarioCadastrado));
}
public async Task <Resposta <bool> > Handle(RemoverCargoComando request, CancellationToken cancellationToken)
{
var erro = _validador.Validar(request);
if (!string.IsNullOrEmpty(erro))
{
return(new Resposta <bool>(erro));
}
var resultado = false;
await _contexto.IniciarTransacao();
var disciplinas = await _cargoDisciplinaRepositorio.Listar(lnq => lnq.CodigoCargo == request.Codigo);
foreach (var disciplina in disciplinas)
{
await _cargoDisciplinaRepositorio.Remover(lnq => lnq.Codigo == disciplina.Codigo);
}
resultado = _cargoRepositorio.Remover(lnq => lnq.Codigo == request.Codigo).Result;
_contexto.FecharTransacao();
return(new Resposta <bool>(resultado));
}
public async Task <Resposta <Usuario> > Handle(AtualizarUsuarioComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <Usuario>(erros));
}
var usuario = new Usuario
{
Codigo = request.Codigo ?? 0,
Ativo = request.Ativo,
Email = request.Email,
Foto = request.Foto,
Login = request.Login,
Nome = request.Nome,
PerfilCodigo = request.PerfilCodigo,
Senha = request.Senha,
Telefone = request.Telefone,
CursoCodigo = request.CursoCodigo
};
var resultado = await _repositorio.Atualizar(usuario);
return(new Resposta <Usuario>(resultado));
}
public async Task <Resposta <string> > Handle(GerarHorarioGeralRelatorioConsulta request, CancellationToken cancellationToken)
{
var erro = _validador.Validar(request);
if (!string.IsNullOrEmpty(erro))
{
return(new Resposta <string>(erro));
}
var curso = await RetornarDescricaoCurso(request.CodigoCurso);
var turno = await RetornarDescricaoTurno(request.CodigoTurno);
var horarios = await RetornarHorarios(request);
var aulas = await RetornarAulas(horarios);
var semestre = request.Semestre.RetornarDescricao();
var dados = new HorarioGeralRelatorioData(request.Ano, curso, turno, semestre, horarios, aulas);
var bytesRelatorio = _relatorioServico.GerarRelatorioHorarioGeral(dados);
var base64 = Convert.ToBase64String(bytesRelatorio);
return(new Resposta <string>(base64, ""));
}
public async Task <Resposta <TurnoViewModel> > Handle(AtualizarTurnoComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <TurnoViewModel>(erros));
}
var turno = await _repositorio.Consultar(lnq => lnq.Codigo == request.Codigo);
if (turno == null)
{
return(new Resposta <TurnoViewModel>("Não foi encontrado um turno com código informado."));
}
turno.Descricao = request.Descricao;
turno.Horarios = request.Horarios.Join(",");
var resultado = await _repositorio.Atualizar(turno);
var turnoViewModel = _mapper.Map <TurnoViewModel>(resultado);
return(new Resposta <TurnoViewModel>(turnoViewModel));
}
public async Task <Resposta <List <string> > > Handle(LancarAulasComando request, CancellationToken cancellationToken)
{
var erro = _validator.Validar(request);
if (!string.IsNullOrEmpty(erro))
{
return(new Resposta <List <string> >(erro));
}
var erros = new List <string>();
foreach (var reserva in request.Reservas)
{
var cadastroAula = await _mediator.Send(new CriarAulaComando
{
CodigoDisciplina = request.CodigoDisciplina,
CodigoHorario = request.CodigoHorario,
CodigoSala = request.CodigoSala,
Laboratorio = request.Laboratorio,
Reserva = reserva
});
if (cadastroAula.TemErro())
{
erros.Add(cadastroAula.GetErros());
}
}
return(new Resposta <List <string> >(erros));
}
public async Task <Resposta <bool> > Handle(RemoverCurriculoDisciplinaComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <bool>(erros));
}
var resultado = await _curriculoDisciplinaRepositorio.Remover(request.Codigo);
return(new Resposta <bool>(resultado));
}
public async Task <Resposta <bool> > Handle(RemoverTurnoComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <bool>(erros));
}
var resultado = await _repositorio.Remover(lnq => lnq.Codigo == request.TurnoId);
return(new Resposta <bool>(resultado));
}
public async Task <Resposta <Unit> > Handle(RemoverHorarioComando request, CancellationToken cancellationToken)
{
var erro = _validador.Validar(request);
if (!string.IsNullOrEmpty(erro))
{
return(new Resposta <Unit>(erro));
}
var repositorioRemover = await _horarioAulaRepositorio.Remover(lnq => lnq.Codigo == request.CodigoHorario);
return(new Resposta <Unit>(Unit.Value));
}
public async Task <Resposta <bool> > Handle(RemoverBlocoComando request, CancellationToken cancellationToken)
{
var mensagemErro = _validador.Validar(request);
if (!string.IsNullOrEmpty(mensagemErro))
{
return(new Resposta <bool>(mensagemErro));
}
bool resultado = await _blocoRepositorio.Remover(lnq => lnq.Codigo == request.Codigo);
return(new Resposta <bool>(resultado));
}
public async Task <Resposta <string> > Handle(LoginComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <string>("", erros));
}
var usuario = await _repositorio.RetornarUsuarioPorLoginESenha(request.Login, request.Senha);
string token = TokenExtension.Gerar(usuario);
return(new Resposta <string>(token, ""));
}
public async Task <Resposta <List <CurriculoDisciplinaViewModel> > > Handle(ListarDisciplinasCurriculoConsulta request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <List <CurriculoDisciplinaViewModel> >(erros));
}
var resultado = await _repositorio.Listar(lnq => lnq.CodigoCurriculo == request.CodigoCurriculo);
var disciplinasViewModel = _mapper.Map <List <CurriculoDisciplinaViewModel> >(resultado);
return(new Resposta <List <CurriculoDisciplinaViewModel> >(disciplinasViewModel));
}
public async Task <Resposta <Curriculo> > Handle(CriarCurriculoComando request, CancellationToken cancellationToken)
{
string erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <Curriculo>(erros));
}
var entidade = _mapper.Map <Curriculo>(request);
var resultado = await _repositorio.Criar(entidade);
return(new Resposta <Curriculo>(resultado));
}
public async Task <Resposta <ICollection <AulaViewModel> > > Handle(ListarAulaPorHorarioConsulta request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <ICollection <AulaViewModel> >(erros));
}
var aulas = await _aulaRepositorio.Listar(lnq => lnq.CodigoHorario == request.CodigoHorario);
var aulasViewModel = await PrepararAulasViewModel(aulas);
return(new Resposta <ICollection <AulaViewModel> >(aulasViewModel));
}
public async Task <Resposta <CargoDisciplinaViewModel> > Handle(CriarCargoDisciplinaComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <CargoDisciplinaViewModel>(erros));
}
var disciplina = await MapearComandoParaDisciplina(request);
disciplina = await _repositorio.Criar(disciplina);
var disciplinaViewModel = _mapper.Map <CargoDisciplinaViewModel>(disciplina);
return(new Resposta <CargoDisciplinaViewModel>(disciplinaViewModel));
}
public async Task <Resposta <CargoViewModel> > Handle(AtualizarCargoComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <CargoViewModel>(erros));
}
var cargo = _mapper.Map <Cargo>(request);
var cargoAtualizado = await _cargoRepositorio.Atualizar(cargo);
var cargoViewModel = _mapper.Map <CargoViewModel>(cargoAtualizado);
return(new Resposta <CargoViewModel>(cargoViewModel));
}
public async Task <Resposta <HorarioAulaViewModel> > Handle(CriarHorarioAulaComando request, CancellationToken cancellationToken)
{
var erro = _validador.Validar(request);
if (!string.IsNullOrEmpty(erro))
{
return(new Resposta <HorarioAulaViewModel>(erro));
}
var horarioInserir = _mapper.Map <HorarioAula>(request);
var horario = await _horarioAulaRepositorio.Criar(horarioInserir);
var horarioViewModel = _mapper.Map <HorarioAulaViewModel>(horario);
return(new Resposta <HorarioAulaViewModel>(horarioViewModel));
}
public async Task <Resposta <BlocoViewModel> > Handle(AtualizarBlocoComando request, CancellationToken cancellationToken)
{
var mensagemErro = _validador.Validar(request);
if (!string.IsNullOrEmpty(mensagemErro))
{
return(new Resposta <BlocoViewModel>(mensagemErro));
}
var blocoEntidade = _mapper.Map <Bloco>(request);
blocoEntidade = await _blocoRepositorio.Atualizar(blocoEntidade);
var blocoViewModel = _mapper.Map <BlocoViewModel>(blocoEntidade);
return(new Resposta <BlocoViewModel>(blocoViewModel));
}
public async Task <Resposta <CargoViewModel> > Handle(CriarCargoComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <CargoViewModel>(erros));
}
var entidade = _mapper.Map <Cargo>(request);
var resultado = await _repositorioCargo.Criar(entidade);
var viewModel = _mapper.Map <CargoViewModel>(resultado);
return(new Resposta <CargoViewModel>(viewModel));
}
public async Task <Resposta <AulaViewModel> > Handle(CriarAulaComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <AulaViewModel>(erros));
}
var aula = _mapper.Map <Aula>(request);
aula = await SalvarAula(aula);
var aulaViewModel = _mapper.Map <AulaViewModel>(aula);
return(new Resposta <AulaViewModel>(aulaViewModel));
}
public async Task <Resposta <bool> > Handle(DefinirSalaComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <bool>(erros));
}
var aula = await _aulaRepositorio.Consultar(request.AulaId);
aula.CodigoSala = request.SalaId;
var resultado = await _aulaRepositorio.Atualizar(aula);
return(new Resposta <bool>(resultado));
}
public int RegistrarReserva(Reserva reserva)
{
var resultado = validador.Validar(reserva);
if (!resultado.Valido)
{
throw new ValidacaoException(resultado);
}
ValidarQuartos(reserva);
var id = repositorio.Adicionar(reserva);
Task.Run(() => AtualizaReservaResumo(reserva));
return(id);
}
public async Task <Resposta <SalaViewModel> > Handle(CriarSalaComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <SalaViewModel>(erros));
}
var salaEntidade = _mapper.Map <Sala>(request);
salaEntidade = await _salaRepositorio.Criar(salaEntidade);
var salaViewModel = _mapper.Map <SalaViewModel>(salaEntidade);
return(new Resposta <SalaViewModel>(salaViewModel));
}
public async Task <Resposta <Curso> > Handle(CriarCursoComando request, CancellationToken cancellationToken)
{
var erro = _validador.Validar(request);
if (!string.IsNullOrEmpty(erro))
{
return(new Resposta <Curso>(erro));
}
var curso = new Curso
{
Descricao = request.Descricao
};
var cursoAdicionado = await _repositorio.Criar(curso);
return(new Resposta <Curso>(cursoAdicionado));
}
public async Task <Resposta <CurriculoDisciplinaViewModel> > Handle(CriarCurriculoDisciplinaComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <CurriculoDisciplinaViewModel>(erros));
}
var entidade = _mapper.Map <CurriculoDisciplina>(request);
entidade.CurriculoDisciplinaPreRequisito = AdicionarPreRequisitors(request.PreRequisitos);
var resultado = await _curriculoDisciplinaRepositorio.Criar(entidade);
var viewModel = _mapper.Map <CurriculoDisciplinaViewModel>(resultado);
return(new Resposta <CurriculoDisciplinaViewModel>(viewModel));
}
public async Task <Resposta <CurriculoDisciplinaViewModel> > Handle(EditarCurriculoDisciplinaComando request, CancellationToken cancellationToken)
{
var erro = _validador.Validar(request);
if (!string.IsNullOrEmpty(erro))
{
return(new Resposta <CurriculoDisciplinaViewModel>(erro));
}
var disciplina = _mapper.Map <CurriculoDisciplina>(request);
disciplina.CurriculoDisciplinaPreRequisito = AdicionarPreRequisitors(request.PreRequisitos);
disciplina = await _curriculoDisciplinaRepositorio.Atualizar(disciplina);
var disciplianViewModel = _mapper.Map <CurriculoDisciplinaViewModel>(disciplina);
return(new Resposta <CurriculoDisciplinaViewModel>(disciplianViewModel));
}
public async Task <Resposta <string> > Handle(AtualizarSenhaComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <string>("", erros));
}
var codigoUsuarioLogado = _usuarioResolverService.RetornarCodigoUsuario();
var usuario = await _repositorio.Consultar(lnq => lnq.Codigo == codigoUsuarioLogado);
usuario.Senha = request.NovaSenha.ToMD5();
await _repositorio.Atualizar(usuario);
return(new Resposta <string>("A senha foi atualizada!", ""));
}
public async Task <Resposta <TurnoViewModel> > Handle(CriarTurnoComando request, CancellationToken cancellationToken)
{
var erro = _validador.Validar(request);
if (!string.IsNullOrEmpty(erro))
{
return(new Resposta <TurnoViewModel>(erro));
}
var turno = new Turno {
Descricao = request.Descricao,
Horarios = request.Horarios.Join(",")
};
var resultado = await _repositorio.Criar(turno);
var turnoViewModel = _mapper.Map <TurnoViewModel>(resultado);
return(new Resposta <TurnoViewModel>(turnoViewModel));
}
public async Task <Resposta <Curriculo> > Handle(AtualizarCurriculoComando request, CancellationToken cancellationToken)
{
var erros = _validador.Validar(request);
if (!string.IsNullOrEmpty(erros))
{
return(new Resposta <Curriculo>(erros));
}
var entidade = _mapper.Map <Curriculo>(request);
var curriculo = await _repositorio.Atualizar(entidade);
if (curriculo.Disciplinas != null && curriculo.Disciplinas.Any())
{
curriculo.Disciplinas = curriculo.Disciplinas.OrderBy(lnq => lnq.Periodo).ToList();
}
return(new Resposta <Curriculo>(curriculo));
}
