public AulaComandoBaseValidador(ISalaRepositorio salaRepositorio,
IHorarioAulaRepositorio horarioAulaRepositorio,
ICargoDisciplinaRepositorio cargoDisciplinaRepositorio)
{
_salaRepositorio = salaRepositorio;
_horarioRepositorio = horarioAulaRepositorio;
_cargoDisciplinaRepositorio = cargoDisciplinaRepositorio;
ValidatorOptions.CascadeMode = CascadeMode.StopOnFirstFailure;
RuleFor(lnq => lnq.CodigoSala)
.NotEmpty()
.WithMessage("O código da sala não pode ser vazio.");
RuleFor(lnq => lnq.CodigoHorario)
.NotEmpty()
.WithMessage("O código do horário não pode ser vazio.");
RuleFor(lnq => lnq.CodigoDisciplina)
.NotEmpty()
.WithMessage("O código da disciplina não pode ser vazio.");
When(ValidarSeCamposComandoForamInformados, () =>
{
RuleFor(lnq => lnq)
.MustAsync(ValidarSeSalaExiste)
.WithMessage(c => $"Não foi encontrada uma sala com o código {c.CodigoSala}.")
.MustAsync(ValidarSeHorarioExiste)
.WithMessage(c => $"Não foi encontrado um horário com o código {c.CodigoHorario}")
.MustAsync(ValidarSeDisciplinaExiste)
.WithMessage(c => $"Não foi encontrada uma disciplina de cargo com o código {c.CodigoDisciplina}.");
});
}
public RemoverCargoComandoHandler(IContexto contexto, ICargoRepositorio cargoRepositorio, ICargoDisciplinaRepositorio cargoDisciplinaRepositorio, IValidador <RemoverCargoComando> validador)
{
_contexto = contexto;
_cargoRepositorio = cargoRepositorio;
_validador = validador;
_cargoDisciplinaRepositorio = cargoDisciplinaRepositorio;
}
public CriarCargoDisciplinaComandoHandler(ICargoDisciplinaRepositorio cargoDisciplinaRepositorio,
IMapper mapper,
IValidador <CriarCargoDisciplinaComando> validador,
ICurriculoDisciplinaRepositorio disciplinaRepositorio) : base(mapper, disciplinaRepositorio)
{
_repositorio = cargoDisciplinaRepositorio;
_validador = validador;
}
public EditarCargoDisciplinaComandoHandler(ICargoDisciplinaRepositorio cargoDisciplinaRepositorio,
IValidador <EditarCargoDisciplinaComando> validador,
IMapper mapper,
ICurriculoDisciplinaRepositorio curriculoDisciplinaRepositorio) : base(mapper, curriculoDisciplinaRepositorio)
{
_cargoDisciplinaRepositorio = cargoDisciplinaRepositorio;
_validador = validador;
}
public LancarAulasComandoValidador(ISalaRepositorio salaRepositorio,
IHorarioAulaRepositorio horarioAulaRepositorio,
ICargoDisciplinaRepositorio cargoDisciplinaRepositorio)
: base(salaRepositorio, horarioAulaRepositorio, cargoDisciplinaRepositorio)
{
RuleFor(lnq => lnq.Reservas)
.NotEmpty()
.WithMessage("Não foram informadas reservas.");
}
public ListarDisciplinasCargoPorCurriculoConsultaHandler(IValidador <ListarDisciplinaCargoPorCurriculoConsulta> validador,
ICargoDisciplinaRepositorio cargoDisciplinaRepositorio,
ICurriculoDisciplinaRepositorio curriculoDisciplinaRepositorio,
IMapper mapper)
{
_validador = validador;
_cargoDisciplinaRepositorio = cargoDisciplinaRepositorio;
_curriculoDisciplinaRepositorio = curriculoDisciplinaRepositorio;
_mapper = mapper;
}
public RemoverCargoDisciplinaComandoValidador(ICargoDisciplinaRepositorio repositorio)
{
_repositorio = repositorio;
RuleFor(lnq => lnq.Codigo).GreaterThan(0).WithMessage("O campo código não pode ser menor ou igual a 0.");
When(lnq => lnq.Codigo > 0, () =>
{
RuleFor(lnq => lnq.Codigo).MustAsync(ValidarSeCargoDisciplinaComandoExiste).WithMessage(c => $"Não foi encontrada uma disciplina com o código {c.Codigo}.");
});
}
public CriarCargoDisciplinaComandoValidador(ICargoDisciplinaRepositorio cargoDisciplinaRepositorio,
ICargoRepositorio cargoRepositorio,
ITurnoRepositorio turnoRepositorio,
ICurriculoDisciplinaRepositorio curriculoDisciplinaRepositorio) :
base(cargoRepositorio, turnoRepositorio, curriculoDisciplinaRepositorio)
{
_cargoDisciplinaRepositorio = cargoDisciplinaRepositorio;
When(lnq => lnq.CodigoCargo > 0 && lnq.CodigoCurriculoDisciplina > 0, () =>
{
RuleFor(lnq => lnq).MustAsync(ValidarSeCargoDisciplinaJaAdicionado).WithMessage("Já foi adicionado uma disciplina com os mesmos valores.");
});
}
public RemoverCurriculoDisciplinaComandoValidador(ICargoDisciplinaRepositorio cargoDisciplinaRepositorio, ICurriculoDisciplinaRepositorio curriculoDisciplinaRepositorio)
{
_cargoDisciplinaRepositorio = cargoDisciplinaRepositorio;
_curriculoDisciplinaRepositorio = curriculoDisciplinaRepositorio;
RuleFor(lnq => lnq.Codigo).NotEmpty().WithMessage("O campo código não pode ser vazio.");
When(lnq => lnq.Codigo > 0, () =>
{
RuleFor(lnq => lnq.Codigo).MustAsync(ValidarSeDisciplinaExiste).WithMessage(c => $"Não foi encontrado uma disciplina do currículo com código {c.Codigo}.");
RuleFor(lnq => lnq.Codigo).MustAsync(ValidarSeDisciplinaVinculadaEmCargo).WithMessage(c => $"Não foi possível remover a disciplina pois ela está vinculada ao cargo de código {_cargo.CodigoCargo}.");
});
}
public CriarAulaComandoValidador(ISalaRepositorio salaRepositorio,
IHorarioAulaRepositorio horarioAulaRepositorio,
IAulaRepositorio aulaRepositorio,
ICargoRepositorio cargoRepositorio,
ICargoDisciplinaRepositorio cargoDisciplinaRepositorio)
: base(salaRepositorio, horarioAulaRepositorio, cargoDisciplinaRepositorio)
{
_aulaRepositorio = aulaRepositorio;
_cargoRepositorio = cargoRepositorio;
ValidatorOptions.CascadeMode = CascadeMode.StopOnFirstFailure;
RuleFor(lnq => lnq.Reserva)
.NotEmpty()
.WithMessage("Não foi reservado horário e dia da semana para a aula")
.DependentRules(() =>
{
RuleFor(lnq => lnq.Reserva.DiaSemana)
.NotEmpty()
.WithMessage("O Dia da semana não pode ser vazio.");
RuleFor(lnq => lnq.Reserva.Hora)
.NotEmpty()
.WithMessage("O campo hora não pode ser vazio.");
});
When(lnq => lnq.Desdobramento, () =>
{
RuleFor(lnq => lnq.DescricaoDesdobramento)
.NotEmpty()
.WithMessage("Não foi informada uma descrição para o desdobramento.");
});
When(ValidarSeCamposComandoForamInformados, () =>
{
RuleFor(lnq => lnq)
.MustAsync(ValidarSeHorarioDisponivel)
.WithMessage(x => $"Não foi possível criar a aula para {x.Reserva.DiaSemana} às {x.Reserva.Hora}h, pois já tem uma aula reservada para esse dia e horário.")
.MustAsync(ValidarSeCargoDisponivel)
.WithMessage(x => $"Não foi possível criar a aula, pois o cargo selecionado já está reservado para {x.Reserva.DiaSemana} às {x.Reserva.Hora}h.")
.MustAsync(ValidarSeProfessorDisponivel)
.WithMessage(x => $"Não foi possível criar a aula, pois o professor selecionado já está reservado para {x.Reserva.DiaSemana} às {x.Reserva.Hora}h.")
.MustAsync(ValidarSeSalaDisponivel)
.WithMessage(x => $"Não foi possível criar a aula, pois a sala selecionada já está reservada para {x.Reserva.DiaSemana} às {x.Reserva.Hora}h.");
});
}
public ListarAulaPorHorarioConsultaHandler(IAulaRepositorio aulaRepositorio,
ICargoDisciplinaRepositorio cargoDisciplinaRepositorio,
ICargoRepositorio cargoRepositorio,
ISalaRepositorio salaRepositorio,
ICurriculoDisciplinaRepositorio curriculoDisciplinaRepositorio,
IValidador <ListarAulaPorHorarioConsulta> validador,
ICargoService cargoService)
{
_aulaRepositorio = aulaRepositorio;
_cargoDisciplinaRepositorio = cargoDisciplinaRepositorio;
_cargoRepositorio = cargoRepositorio;
_validador = validador;
_salaRepositorio = salaRepositorio;
_curriculoDisciplinaRepositorio = curriculoDisciplinaRepositorio;
_cargoService = cargoService;
}
public GerarHorarioIndividualRelatorioConsultaHandler(IRelatorioServico relatorioServico,
IProfessorRepositorio professorRepositorio,
ICargoRepositorio cargoRepositorio,
ICargoDisciplinaRepositorio cargoDisciplinaRepositorio,
ICurriculoDisciplinaRepositorio curriculoDisciplinaRepositorio,
ICurriculoRepositorio curriculoRepositorio,
IAulaRepositorio aulaRepositorio)
{
_relatorioServico = relatorioServico;
_professorRepositorio = professorRepositorio;
_cargoRepositorio = cargoRepositorio;
_cargoDisciplinaRepositorio = cargoDisciplinaRepositorio;
_curriculoDisciplinaRepositorio = curriculoDisciplinaRepositorio;
_curriculoRepositorio = curriculoRepositorio;
_aulaRepositorio = aulaRepositorio;
}
public RemoverTurnoComandoValidador(ITurnoRepositorio repositorio,
ICargoDisciplinaRepositorio cargoDisciplinaRepositorio,
IHorarioAulaRepositorio horarioAulaRepositorio)
{
_repositorio = repositorio;
_cargoDisciplinaRepositorio = cargoDisciplinaRepositorio;
_horarioAulaRepositorio = horarioAulaRepositorio;
ValidatorOptions.CascadeMode = CascadeMode.StopOnFirstFailure;
RuleFor(lnq => lnq.TurnoId)
.NotEmpty()
.WithMessage("O código do turno não pode ser vazio")
.MustAsync(ValdiarTurnoExistente)
.WithMessage(lnq => $"Não foi encontrado um turno com o código {lnq.TurnoId}.")
.MustAsync(ValidarSeTurnoTemVinculoComDisciplinaDeCargo)
.WithMessage(c => $"Não foi possível remover o turno pois ele está vinculado a disciplina do cargo de código {_cargoDisciplina.CodigoCargo}.")
.MustAsync(ValidarSeTurnoEstaVinculadoEmHorario)
.WithMessage("Não foi possível remover o turno pois ele está vinculado em horarios.");
}
public ListarTodasDisciplinasCargoConsultaHandler(ICargoDisciplinaRepositorio repositorio, IMapper mapper, IValidador <ListarTodasDisciplinasCargoConsulta> validador)
{
_repositorio = repositorio;
_mapper = mapper;
_validador = validador;
}
public RemoverCargoDisciplinaComandoHandler(ICargoDisciplinaRepositorio cargoDisciplinaRepositorio, IValidador <RemoverCargoDisciplinaComando> validador)
{
_cargoDisciplinaRepositorio = cargoDisciplinaRepositorio;
_validador = validador;
}
