Пример #1
0
        public async Task <EduProcessaHorarioAtividadeProfessor> Processar(
            SAtividadeProfessor atividadeProfessor, IList <SHorario> horarios)
        {
            var turmasProfessor = await GetProfessorTurmasAsync(atividadeProfessor.CodProf,
                                                                atividadeProfessor.DtInicio.Value, atividadeProfessor.DtTermino.Value);

            var atividadesProfessor = await GetAtividadesProfessorAsync(atividadeProfessor.CodProf,
                                                                        atividadeProfessor.DtInicio.Value, atividadeProfessor.DtTermino.Value);

            var horariosProfessores = await GetHorariosProfessorAsync(turmasProfessor);

            var horariosTurma = await GetHorariosTurmasAsync(horariosProfessores);

            var disciplinasProfessor = await GetDisciplinasProfessorAsync(turmasProfessor);


            var  choquesHorarioProfessor          = new List <SHorarioTurma>();
            var  choquesHorarioAtividadeProfessor = new List <SHorarioAtivProf>();
            var  horariosProcessados    = new List <SHorarioAtivProf>();
            bool existeChoque           = false;
            bool isCargaHorariaExcedida = false;

            foreach (var horario in horarios)
            {
                var horaInicial = horario.GetHorarioInicialInt();
                var horaFinal   = horario.GetHorarioFinalInt();

                var choqueHorarioProfessor = SHorarioTurma.GetChoqueHorario(horariosTurma, atividadeProfessor.DtInicio.Value,
                                                                            atividadeProfessor.DtTermino.Value, horaInicial, horaFinal, horario.DiaSemana);
                if (choqueHorarioProfessor.Count > 0)
                {
                    foreach (var choque in choqueHorarioProfessor)
                    {
                        choquesHorarioProfessor.Add(choque);
                    }
                    existeChoque = true;
                    continue;
                }

                var choqueHorarioAtividadeProfessor = SAtividadeProfessor.GetChoqueAtividade(atividadesProfessor,
                                                                                             atividadeProfessor.DtInicio.Value, atividadeProfessor.DtTermino.Value, horaInicial, horaFinal, horario.DiaSemana);
                if (choqueHorarioAtividadeProfessor.Count > 0)
                {
                    foreach (var choque in choqueHorarioAtividadeProfessor)
                    {
                        choquesHorarioAtividadeProfessor.Add(choque);
                    }
                    existeChoque = true;
                    continue;
                }

                var cargaHorariaProcessada = horario.GetCargaHoraria();
                if (atividadeProfessor.GetCargaHoraria() < cargaHorariaProcessada + atividadeProfessor.CargaHorariaCadastrada)
                {
                    isCargaHorariaExcedida = true;
                    break;
                }

                var horarioProcessado = new SHorarioAtivProf
                {
                    CodColigada       = atividadeProfessor.CodColigada,
                    IdAtividadeProf   = atividadeProfessor.IdAtividadeProf,
                    CodHor            = horario.CodHor,
                    DiaSemana         = horario.DiaSemana.ToString(),
                    DataInicio        = atividadeProfessor.DtInicio.Value,
                    DataFim           = atividadeProfessor.DtTermino.Value,
                    HoraInicio        = horario.HoraInicial,
                    HoraFim           = horario.HoraFinal,
                    DesconsideraPonto = "N"
                };


                horariosProcessados.Add(horarioProcessado);
                atividadeProfessor.SHorarioAtivProf.Add(horarioProcessado);

                if (atividadeProfessor.IsCargaHorariaPreenchida())
                {
                    break;
                }
            }

            atividadeProfessor.SHorarioAtivProf = horariosProcessados;

            return(new EduProcessaHorarioAtividadeProfessor
            {
                ExisteChoque = existeChoque,
                IsCargaHorariaExcedida = isCargaHorariaExcedida,
                ChoquesHorarioAtividadeProfessor = choquesHorarioAtividadeProfessor,
                ChoquesHorarioProfessor = choquesHorarioProfessor,
                AtividadeProfessor = atividadeProfessor,
                DisciplinasProfessor = disciplinasProfessor
            });
        }
Пример #2
0
        public async Task <EduProcessaHorarioTurma> ProcessarAsync(
            EduProcessaHorarioTurmaParams parametros)
        {
            var periodoLetivo = await _periodoLetivoData.GetAsync(parametros.STurmaDisc.GetPeriodoLetivoId());

            var calendario = await _calendarioData.GetAsync(periodoLetivo.Data.Calendario);

            var turmasProfessores =
                await GetProfessoresAsync(
                    parametros.Professores.Select(p => p.CodProf).Distinct().ToList(),
                    parametros.STurmaDisc.DtInicial.Value,
                    parametros.STurmaDisc.DtFinal.Value
                    );

            var disciplinasProfessores = await GetDisciplinasTurmaAsync(turmasProfessores.Select(tp => tp.IdTurmaDisc).Distinct().ToList());

            var atividadesProfessores =
                await GetAtividadesAsync(
                    parametros.Professores.Select(p => p.CodProf).Distinct().ToList(),
                    parametros.STurmaDisc.DtInicial.Value,
                    parametros.STurmaDisc.DtFinal.Value
                    );

            var horariosAtividadesProfessores = await GetAtividadesAsync(atividadesProfessores);

            var horariosProfessores = await GetHorariosDisciplinasAsync(turmasProfessores.Select(tp => tp.IdTurmaDisc).Distinct().ToList());

            var disciplinasTurma = await GetDisciplinasTurmaAsync(parametros.STurmaDisc.IdPerLet, parametros.STurmaDisc.CodTurma);

            var horariosDisciplina = await GetHorariosDisciplinaAsync(parametros.STurmaDisc.IdTurmaDisc);

            decimal chCadastrada = 0;

            if (horariosDisciplina != null)
            {
                chCadastrada = (decimal)horariosDisciplina.Sum(h => Formater.TimeToInt(h.HoraFinal) - Formater.TimeToInt(h.HoraInicial));
            }

            var data         = parametros.STurmaDisc.DtInicial.Value;
            var contadorAula = chCadastrada;

            IList <SHorarioTurma> horariosDisciplinasTurma = null;

            if (parametros.VerificaChoqueTurma)
            {
                horariosDisciplinasTurma = await GetHorariosDisciplinasAsync(disciplinasTurma.Select(dt => dt.IdTurmaDisc).Distinct().ToList());
            }

            var  choquesFeriado                   = new List <GFeriado>();
            var  choquesHorarioTurma              = new List <SHorarioTurma>();
            var  choquesHorarioProfessor          = new List <SHorarioTurma>();
            var  choquesHorarioAtividadeProfessor = new List <SHorarioAtivProf>();
            var  horariosTurma = new List <Horario>();
            bool existeChoque  = false;
            bool isFeriado     = false;

            while (data <= parametros.STurmaDisc.DtFinal)
            {
                foreach (var horario in parametros.Horarios)
                {
                    var horaInicial = Formater.TimeToInt(horario.HoraInicial);
                    var horaFinal   = Formater.TimeToInt(horario.HoraFinal);
                    var tempoAula   = horaFinal - horaInicial;

                    if (horario.DiaSemana == (int)data.DayOfWeek + 1)
                    {
                        var choqueHorarioDisciplina = SHorarioTurma.GetChoqueHorario(horariosDisciplina, data, data, horaInicial, horaFinal, horario.DiaSemana);
                        if (choqueHorarioDisciplina.Count > 0)
                        {
                            continue;
                        }

                        var choqueHorarioProfessor = SHorarioTurma.GetChoqueHorario(horariosProfessores, data, data, horaInicial, horaFinal, horario.DiaSemana);
                        if (choqueHorarioProfessor.Count > 0)
                        {
                            foreach (var choque in choqueHorarioProfessor)
                            {
                                choquesHorarioProfessor.Add(choque);
                            }
                            existeChoque = true;
                            continue;
                        }

                        foreach (var atividade in horariosAtividadesProfessores)
                        {
                            var choqueHorarioAtividadeProfessor = SAtividadeProfessor.GetChoqueAtividade(atividade.SHorarioAtivProf, data, data, horaInicial, horaFinal, horario.DiaSemana);
                            if (choqueHorarioAtividadeProfessor.Count > 0)
                            {
                                foreach (var choque in choqueHorarioAtividadeProfessor)
                                {
                                    choquesHorarioAtividadeProfessor.Add(choque);
                                }
                                existeChoque = true;
                                continue;
                            }
                        }


                        var feriado = GCalend.GetChoqueFeriado(calendario.Data, data, horaInicial, horaFinal);
                        if (feriado != null)
                        {
                            isFeriado = true;
                            choquesFeriado.Add(feriado);
                            existeChoque = true;
                            continue;
                        }
                        else
                        {
                            isFeriado = false;
                        }


                        var choqueHorarioTurma = SHorarioTurma.GetChoqueHorario(horariosDisciplinasTurma, data, data, horaInicial, horaFinal, horario.DiaSemana);
                        if (choqueHorarioTurma.Count > 0)
                        {
                            foreach (var choque in choqueHorarioTurma)
                            {
                                choquesHorarioTurma.Add(choque);
                            }
                            existeChoque = true;
                            continue;
                        }


                        contadorAula += tempoAula;

                        if (contadorAula <= parametros.SDisciplina.CH)
                        {
                            horariosTurma.Add(new Horario
                            {
                                CodColigada         = horario.CodColigada,
                                CodHor              = horario.CodHor,
                                DataInicial         = data,
                                DataFinal           = data,
                                HoraInicial         = horario.HoraInicial,
                                HoraFinal           = horario.HoraFinal,
                                DiaSemana           = (short)horario.DiaSemana,
                                ListaProfessorTurma = parametros.Professores
                            });
                        }
                    }
                }

                if (contadorAula > 0)
                {
                    if ((int)data.DayOfWeek == 6)
                    {
                        if (parametros.Recorrencia == Recorrencia.Quinzenal && isFeriado == false)
                        {
                            data = data.AddDays(7);
                        }
                    }
                }

                data = data.AddDays(1);

                if (contadorAula >= parametros.SDisciplina.CH)
                {
                    break;
                }
            }


            var isCHIncompleta = (parametros.SDisciplina.CH > chCadastrada + contadorAula);

            if (isCHIncompleta == true)
            {
                existeChoque = true;
            }

            return(new EduProcessaHorarioTurma
            {
                AtividadesProfessores = atividadesProfessores,
                ChoquesFeriado = choquesFeriado.Distinct().ToList(),
                choquesHorarioAtividadeProfessores = choquesHorarioAtividadeProfessor,
                choquesHorarioProfessores = choquesHorarioProfessor,
                ChoquesHorarioTurma = choquesHorarioTurma,
                CHProcessada = contadorAula / 60,
                CHDisciplina = parametros.SDisciplina.CH.Value / 60,
                CHCadastrada = chCadastrada / 60,
                TurmasProfessores = turmasProfessores,
                DisciplinasTurma = disciplinasTurma,
                DisciplinasProfessores = disciplinasProfessores,
                HorariosInclusao = horariosTurma,
                ProfessoresInclusao = parametros.Professores,
                NomeDisciplina = parametros.SDisciplina.Nome,
                ExisteChoque = existeChoque,
                IsCHIncompleta = isCHIncompleta,
                STurmaDisc = parametros.STurmaDisc
            });
        }