Exemplo n.º 1
0
        public new static bool Delete(CLS_CompensacaoAusencia entity)
        {
            CLS_CompensacaoAusenciaDAO dao = new CLS_CompensacaoAusenciaDAO();

            dao._Banco.Open(IsolationLevel.ReadCommitted);

            try
            {
                ACA_FormatoAvaliacao formatoAvaliacao = ACA_FormatoAvaliacaoBO.CarregarPorTud(entity.tud_id);
                // Caso o fechamento seja automático, grava na fila de processamento.
                if (formatoAvaliacao.fav_fechamentoAutomatico && entity.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, new Guid()))
                {
                    CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(entity.tud_id, entity.tpc_id, dao._Banco);
                }

                CLS_CompensacaoAusenciaAlunoDAO daoAluno = new CLS_CompensacaoAusenciaAlunoDAO {
                    _Banco = dao._Banco
                };

                List <CLS_CompensacaoAusenciaAluno> listaBanco = daoAluno.SelectByCpa_id(entity.cpa_id, entity.tud_id);

                foreach (CLS_CompensacaoAusenciaAluno item in listaBanco)
                {
                    if (!daoAluno.Delete(item))
                    {
                        throw new Exception("Erro ao tentar excluir compensação de ausência do aluno.");
                    }
                }

                // Exclui CLS_CompensacaoAusencia
                if (!dao.Delete(entity))
                {
                    throw new Exception("Erro ao tentar excluir compensação de ausência.");
                }

                return(true);
            }
            catch (Exception err)
            {
                dao._Banco.Close(err);

                throw err;
            }
            finally
            {
                //Fechamento da transação
                dao._Banco.Close();
            }
        }
        /// <summary>
        /// Realiza as validações necessárias e salva a atividade extraclasse.
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public static bool Salvar(CLS_TurmaAtividadeExtraClasse entity, int cal_id, bool fechamentoAutomatico, Guid ent_id, List <long> lstDisciplinas, Guid usu_id, long tur_id)
        {
            TalkDBTransaction banco = new CLS_TurmaAtividadeExtraClasseDAO()._Banco.CopyThisInstance();

            banco.Open(IsolationLevel.ReadCommitted);
            try
            {
                List <CLS_TurmaAtividadeExtraClasse> lstEntities = new List <CLS_TurmaAtividadeExtraClasse>();

                bool isNew = entity.IsNew;
                if (lstDisciplinas.Count > 0)
                {
                    if (isNew)
                    {
                        CLS_TurmaAtividadeExtraClasseRelacionada relacionada = new CLS_TurmaAtividadeExtraClasseRelacionada();
                        relacionada.IsNew  = true;
                        relacionada.usu_id = usu_id;
                        if (CLS_TurmaAtividadeExtraClasseRelacionadaBO.Save(relacionada, banco))
                        {
                            entity.taer_id = relacionada.taer_id;
                            lstDisciplinas.ForEach(p =>
                            {
                                if (p != entity.tud_id)
                                {
                                    lstEntities.Add(new CLS_TurmaAtividadeExtraClasse {
                                        tud_id = p, tae_id = -1, taer_id = entity.taer_id, IsNew = true
                                    });
                                }
                            });
                        }
                        else
                        {
                            throw new Exception("Erro ao tentar salvar componente curricular relacionado.");
                        }
                    }
                    else
                    {
                        List <CLS_TurmaAtividadeExtraClasse> lstRelacionadas = SelecionaAtividadeExtraclasseRelacionada(entity.taer_id);
                        if (lstRelacionadas.Count > 0)
                        {
                            lstEntities.AddRange(lstRelacionadas.FindAll(p => p.tud_id != entity.tud_id));
                        }
                    }

                    lstEntities.ForEach(p =>
                    {
                        p.tpc_id           = entity.tpc_id;
                        p.tav_id           = entity.tav_id;
                        p.tae_nome         = entity.tae_nome;
                        p.tae_descricao    = entity.tae_descricao;
                        p.tae_cargaHoraria = entity.tae_cargaHoraria;
                        p.tdt_posicao      = entity.tdt_posicao;
                        p.IsNew            = p.tae_id <= 0;
                    });
                }

                lstEntities.Add(entity);
                List <TUR_TurmaDisciplina> turmaDisciplina = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, null, GestaoEscolarUtilBO.MinutosCacheLongo);

                CLS_TurmaAtividadeExtraClasseDAO dao = new CLS_TurmaAtividadeExtraClasseDAO();
                dao._Banco = banco;
                foreach (CLS_TurmaAtividadeExtraClasse atividade in lstEntities)
                {
                    if (atividade.Validate())
                    {
                        if (VerificaExistePorDisciplinaNomeTipoBimestre(atividade))
                        {
                            throw new ValidationException(string.Format("Já existe uma atividade extraclasse com o mesmo nome e tipo para o componente curricular '{0}' no bimestre.", TUR_TurmaDisciplinaBO.GetEntity(new TUR_TurmaDisciplina {
                                tud_id = atividade.tud_id
                            }).tud_nome));
                        }

                        decimal dis_cargaHorariaExtraClasse = 0, cargaAtividadeExtraTotal = 0;

                        if (VerificaCargaHorariaCursoCalendario(atividade, cal_id, out dis_cargaHorariaExtraClasse, out cargaAtividadeExtraTotal))
                        {
                            throw new ValidationException(string.Format("A soma de carga horária de atividades extraclasse ({0}) está acima da máxima permitida pelo componente curricular '{1}' ({2}).", cargaAtividadeExtraTotal, TUR_TurmaDisciplinaBO.GetEntity(new TUR_TurmaDisciplina {
                                tud_id = atividade.tud_id
                            }).tud_nome, dis_cargaHorariaExtraClasse));
                        }

                        if (dao.Salvar(atividade))
                        {
                            // Caso o fechamento seja automático, grava na fila de processamento.
                            if (!isNew && fechamentoAutomatico &&
                                turmaDisciplina.Find(t => t.tud_id == atividade.tud_id).tud_tipo != (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia &&
                                atividade.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
                            {
                                CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(atividade.tud_id, atividade.tpc_id, banco);
                            }
                        }
                    }
                }
                return(true);
            }
            catch (Exception ex)
            {
                banco.Close(ex);
                throw;
            }
            finally
            {
                if (banco.ConnectionIsOpen)
                {
                    banco.Close();
                }
            }

            throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
        }
        /// <summary>
        /// Salva as notas das atividades extraclasse
        /// </summary>
        /// <param name="lstTurmaAtividadeExtraClasseAluno"></param>
        /// <returns></returns>
        public static bool SalvarEmLote(List <CLS_TurmaAtividadeExtraClasseAluno> lstTurmaAtividadeExtraClasseAluno, long tud_id, int tpc_id, byte tud_tipo, bool fechamentoAutomatico, Guid ent_id, List <CLS_TurmaAtividadeExtraClasse> lstRelacionamento, long tur_id)
        {
            TalkDBTransaction banco = new CLS_TurmaAtividadeExtraClasseAlunoDAO()._Banco.CopyThisInstance();

            banco.Open(IsolationLevel.ReadCommitted);
            try
            {
                List <long> lstTudId = new List <long>();
                foreach (CLS_TurmaAtividadeExtraClasse atividade in lstRelacionamento)
                {
                    List <CLS_TurmaAtividadeExtraClasse>      lstRelacionadas        = CLS_TurmaAtividadeExtraClasseBO.SelecionaAtividadeExtraclasseRelacionada(atividade.taer_id);
                    List <CLS_TurmaAtividadeExtraClasseAluno> lstLancamento          = lstTurmaAtividadeExtraClasseAluno.FindAll(p => p.tud_id == atividade.tud_id && p.tae_id == atividade.tae_id);
                    List <MTR_MatriculaTurmaDisciplina>       lstMatriculaDisciplina = new List <MTR_MatriculaTurmaDisciplina>();

                    lstRelacionadas.FindAll(p => p.tud_id != atividade.tud_id || p.tae_id != atividade.tae_id).ForEach(p =>
                    {
                        if (!lstMatriculaDisciplina.Any(m => m.tud_id == p.tud_id))
                        {
                            lstMatriculaDisciplina.AddRange(MTR_MatriculaTurmaDisciplinaBO.SelecionaMatriculasPorTurmaDisciplina(p.tud_id.ToString(), banco));
                        }
                        lstLancamento.ForEach(a =>
                        {
                            CLS_TurmaAtividadeExtraClasseAluno ent = new CLS_TurmaAtividadeExtraClasseAluno
                            {
                                tud_id            = p.tud_id,
                                tae_id            = p.tae_id,
                                alu_id            = a.alu_id,
                                mtu_id            = a.mtu_id,
                                mtd_id            = lstMatriculaDisciplina.Find(m => m.alu_id == a.alu_id && m.mtu_id == a.mtu_id && m.tud_id == p.tud_id).mtd_id,
                                aea_avaliacao     = a.aea_avaliacao,
                                aea_relatorio     = a.aea_relatorio,
                                aea_entregue      = a.aea_entregue,
                                aea_dataAlteracao = a.aea_dataAlteracao,
                                aea_situacao      = 1
                            };
                            lstTurmaAtividadeExtraClasseAluno.Add(ent);
                        });
                        if (!lstTudId.Any(t => t == p.tud_id))
                        {
                            lstTudId.Add(p.tud_id);
                        }
                    });
                }

                using (DataTable dt = lstTurmaAtividadeExtraClasseAluno.Select(p => new TipoTabela_TurmaAtividadeExtraClasseALuno(p).ToDataRow()).CopyToDataTable())
                {
                    CLS_TurmaAtividadeExtraClasseAlunoDAO dao = new CLS_TurmaAtividadeExtraClasseAlunoDAO();
                    dao._Banco = banco;
                    if (dao.SalvarEmLote(dt))
                    {
                        // Caso o fechamento seja automático, grava na fila de processamento.
                        if (fechamentoAutomatico && tud_tipo != (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia && tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
                        {
                            CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(tud_id, tpc_id, banco);
                        }

                        if (lstTudId.Any())
                        {
                            List <TUR_TurmaDisciplina> turmaDisciplina = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, null, GestaoEscolarUtilBO.MinutosCacheLongo);
                            lstTudId.ForEach(p =>
                            {
                                if (fechamentoAutomatico && turmaDisciplina.Find(t => t.tud_id == p).tud_tipo != (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia && tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
                                {
                                    CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(p, tpc_id, banco);
                                }
                            }
                                             );
                        }
                        return(true);
                    }

                    return(false);
                }
            }
            catch (Exception ex)
            {
                banco.Close(ex);
                throw;
            }
            finally
            {
                if (banco.ConnectionIsOpen)
                {
                    banco.Close();
                }
            }
        }
Exemplo n.º 4
0
        /// <summary>
        /// Salva a lista de aulas previstas, validando as entidades.
        /// </summary>
        /// <param name="lista"></param>
        /// <returns></returns>
        public static bool SalvarAulasPrevistas(List <TUR_TurmaDisciplinaAulaPrevista> lista, List <TUR_TurmaDisciplinaAulaPrevista> listaProcessarPend, Guid ent_id, int esc_id, long doc_id, bool fechamentoAutomatico)
        {
            TalkDBTransaction banco = new TUR_TurmaDisciplinaAulaPrevistaDAO()._Banco.CopyThisInstance();

            try
            {
                banco.Open();
                bool ret = true;

                foreach (TUR_TurmaDisciplinaAulaPrevista entity in lista)
                {
                    if (!entity.Validate())
                    {
                        throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
                    }

                    ret &= Save(entity, banco);
                }

                foreach (var listaTudTpc in listaProcessarPend.Select(tap => new { tap.tud_id, tap.tud_tipo, tap.tpc_id }).Distinct())
                {
                    // Caso o fechamento seja automático, grava na fila de processamento.
                    if (fechamentoAutomatico && listaProcessarPend.Count > 0 && listaTudTpc.tud_tipo != (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia && listaTudTpc.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
                    {
                        CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(listaTudTpc.tud_id, listaTudTpc.tpc_id, banco);
                    }
                }

                if (lista.Count > 0 && ret && HttpContext.Current != null)
                {
                    try
                    {
                        // Limpa o cache da lista de turmas, para atualizar o check
                        string chave = TUR_TurmaBO.RetornaChaveCache_GestorMinhaEscola(ent_id, esc_id);
                        HttpContext.Current.Cache.Remove(chave);

                        if (doc_id > 0)
                        {
                            chave = TUR_TurmaBO.RetornaChaveCache_DocenteControleTurmas(ent_id, doc_id);
                            HttpContext.Current.Cache.Remove(chave);
                        }
                        else
                        {
                            GestaoEscolarUtilBO.LimpaCache(string.Format("{0}_{1}", TUR_TurmaDisciplinaBO.Cache_SelecionaPorDocenteControleTurma, ent_id));
                        }

                        // Limpa o cache do fechamento
                        long tud_id = lista[0].tud_id;
                        GestaoEscolarUtilBO.LimpaCache(ModelCache.FECHAMENTO_BIMESTRE_PATTERN_KEY, tud_id.ToString());
                        GestaoEscolarUtilBO.LimpaCache(ModelCache.FECHAMENTO_BIMESTRE_FILTRO_DEFICIENCIA_PATTERN_KEY, tud_id.ToString());
                        GestaoEscolarUtilBO.LimpaCache(string.Format(ModelCache.TURMA_DISCIPLINA_AULA_PREVISTA_MODEL_KEY, tud_id));
                        GestaoEscolarUtilBO.LimpaCache(string.Format(ModelCache.TURMA_SELECIONA_POR_DOCENTE_CONTROLE_TURMA_MODEL_KEY, ent_id.ToString(), doc_id.ToString()));
                    }
                    catch
                    { }
                }

                return(ret);
            }
            catch (Exception ex)
            {
                banco.Close(ex);
                throw ex;
            }
            finally
            {
                banco.Close();
            }
        }
Exemplo n.º 5
0
        /// <summary>
        /// Gera as aulas do planejamento diário.
        /// </summary>
        /// <param name="tagsSalvar">Lista de CLS_TurmaAulaGerada para gravar</param>
        /// <param name="doc_id">Docente para quem devem ser geradas as CLS_TurmaAula correspondentes</param>
        /// <param name="usu_id">ID do usuário logado.</param>
        /// <param name="ent_id">ID da entidade do usuário logado</param>
        /// <param name="gerouTodasAulas">Flag que indica se todas as aulas foram salvas.</param>
        /// <param name="ultrapassouCargaHorariaSemanal">Lista de alertas para os itens que não foram plenamente atendidos.</param>
        /// <returns></returns>
        public static bool GerarAulasPlanejamentoDiario
        (
            List <CLS_TurmaAulaGerada> tagsSalvar,
            int tpc_id,
            long doc_id,
            DateTime?dataInicial,
            DateTime?dataFinal,
            Guid usu_id,
            Guid ent_id,
            Dictionary <long, string> dicTurmasDisciplinas,
            out bool gerouTodasAulas,
            out Dictionary <long, string> ultrapassouCargaHorariaSemanal,
            out Dictionary <long, string> semVigencia,
            out Dictionary <long, string> semAulasPrevistas,
            out Dictionary <long, Exception> outrosErros,
            byte origemLogAula = 0
        )
        {
            gerouTodasAulas = true;
            ultrapassouCargaHorariaSemanal = new Dictionary <long, string>();
            semVigencia       = new Dictionary <long, string>();
            semAulasPrevistas = new Dictionary <long, string>();
            outrosErros       = new Dictionary <long, Exception>();
            Dictionary <long, string> ultrapassouCargaHorariaSemanalTerritorio = new Dictionary <long, string>();

            // armazenará os períodos de cada calendário
            var dicPeriodosCalendario = new Dictionary <int, DataTable>();
            // armazenará os dias não-úteis de cada escola
            var dicDiasNaoUteis = new Dictionary <int, List <DateTime> >();

            DateTime dataLimiteLancamento = new DateTime();
            string   dataBloqueio         = ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.DATA_VALIDADE_BLOQUEIO_ACESSO_MINHAS_TURMAS, ent_id);

            if (!string.IsNullOrEmpty(dataBloqueio))
            {
                if (!DateTime.TryParse(dataBloqueio, out dataLimiteLancamento))
                {
                    dataLimiteLancamento = new DateTime();
                }
                //throw new ValidationException("A data de bloqueio informada no parâmetro não é válida.");
            }

            #region Valida itens que bloqueiam toda a execução e preenche listas de calendários

            // utilizadas na verificação de carga horária semanal, cuja soma precisa ser verificada por tud_id
            long tud_id_anterior         = 0;
            int  tud_cargaHorariaSemanal = 0;

            foreach (var tag in tagsSalvar.OrderBy(tag => tag.tud_id))
            {
                if (tud_id_anterior != tag.tud_id)
                {
                    tud_id_anterior         = tag.tud_id;
                    tud_cargaHorariaSemanal = 0;
                }

                tud_cargaHorariaSemanal += tag.tag_numeroAulas;
                if (tud_cargaHorariaSemanal > tag.tud_cargaHorariaSemanal)
                {
                    throw new ValidationException(string.Format("{0} excede a carga horária semanal permitida.", dicTurmasDisciplinas[tag.tud_id]));
                }

                var cap_dataInicio = new DateTime();
                var cap_dataFim    = new DateTime();

                #region Preenche as listas de calendários, cap_dataInicio e cap_dataFim

                DataTable cal = null;

                if (dicPeriodosCalendario.Any(i => i.Key == tag.cal_id))
                {
                    cal = dicPeriodosCalendario.First(i => i.Key == tag.cal_id).Value;
                }
                else
                {
                    cal = ACA_TipoPeriodoCalendarioBO.SelecionaTipoPeriodoCalendarioPorTipoPeriodoCalendario(tpc_id, tag.cal_id);
                    dicPeriodosCalendario.Add(tag.cal_id, cal);
                }

                cap_dataInicio = Convert.ToDateTime(cal.Rows[0]["cap_dataInicio"]);
                cap_dataFim    = Convert.ToDateTime(cal.Rows[0]["cap_dataFim"]);

                if (!dicDiasNaoUteis.Any(i => i.Key == tag.esc_id))
                {
                    dicDiasNaoUteis.Add(tag.esc_id, ACA_CalendarioPeriodoBO.SelecionaDiasNaoUteis(tag.esc_id, tag.uni_id, tag.cal_id, cap_dataInicio, cap_dataFim, ent_id));
                }

                #endregion

                if (dataInicial.HasValue &&
                    (dataInicial < cap_dataInicio || dataInicial > cap_dataFim))
                {
                    throw new ArgumentException(String.Format(CustomResource.GetGlobalResourceObject("BLL", "TurmaAula.ValidaDataInicioBimestre"),
                                                              cap_dataInicio.ToShortDateString(),
                                                              cap_dataFim.ToShortDateString()));
                }

                if (dataFinal.HasValue &&
                    (dataFinal < cap_dataInicio || dataFinal > cap_dataFim))
                {
                    throw new ArgumentException(String.Format(CustomResource.GetGlobalResourceObject("BLL", "TurmaAula.ValidaDataFimBimestre"),
                                                              cap_dataInicio.ToShortDateString(),
                                                              cap_dataFim.ToShortDateString()));
                }
            }

            #endregion

            var dao = new CLS_TurmaAulaGeradaDAO();
            foreach (var tud_id in tagsSalvar.Select(tag => tag.tud_id).Distinct())
            {
                var banco = dao._Banco.CopyThisInstance();

                try
                {
                    banco.Open(IsolationLevel.ReadCommitted);

                    #region Busca dados iniciais do tud.

                    var tagsByTud = tagsSalvar.Where(t => t.tud_id == tud_id).ToList();

                    var tud_tipo = tagsByTud.First().tud_tipo;

                    var fav_tipoApuracaoFrequencia = tagsByTud.First().fav_tipoApuracaoFrequencia;

                    var ttn_tipo = tagsByTud.First().ttn_tipo;

                    if (((tud_tipo == (byte)TurmaDisciplinaTipo.Regencia && fav_tipoApuracaoFrequencia != (byte)ACA_FormatoAvaliacaoTipoApuracaoFrequencia.TemposAula) ||
                         (tud_tipo == (byte)TurmaDisciplinaTipo.DisciplinaPrincipal && ttn_tipo != (byte)ACA_TipoTurnoBO.TipoTurno.Integral)) && tagsByTud.Any(tag => tag.tag_numeroAulas > 1))
                    {
                        throw new ValidationException(string.Format("A carga horária diária do componente {0} não deve ser maior que 1.", dicTurmasDisciplinas[tud_id]));
                    }

                    if (tud_tipo == (byte)TurmaDisciplinaTipo.DisciplinaPrincipal && ttn_tipo == (byte)ACA_TipoTurnoBO.TipoTurno.Integral && tagsByTud.Any(tag => tag.tag_numeroAulas > 2))
                    {
                        throw new ValidationException(string.Format("A carga horária diária do componente {0} não deve ser maior que 2.", dicTurmasDisciplinas[tud_id]));
                    }

                    tud_cargaHorariaSemanal = tagsByTud.First().tud_cargaHorariaSemanal;

                    var cal    = dicPeriodosCalendario.First(i => i.Key == tagsByTud.First().cal_id).Value;
                    var inicio = dataInicial.GetValueOrDefault(Convert.ToDateTime(cal.Rows[0]["cap_dataInicio"]));
                    var fim    = dataFinal.GetValueOrDefault(Convert.ToDateTime(cal.Rows[0]["cap_dataFim"]));

                    var cap_dataInicio = dataInicial.GetValueOrDefault(Convert.ToDateTime(cal.Rows[0]["cap_dataInicio"]));
                    var cap_dataFim    = dataFinal.GetValueOrDefault(Convert.ToDateTime(cal.Rows[0]["cap_dataFim"]));

                    string tud_ids = tud_id.ToString();

                    List <TUR_TurmaDisciplinaTerritorio> territorios = null;
                    if (tagsByTud.First().tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia)
                    {
                        territorios = TUR_TurmaDisciplinaTerritorioBO.SelecionaVigentesPorExperienciaPeriodo(tud_id, inicio, fim);
                        tud_ids     = territorios.Aggregate(tud_ids, (a, i) => string.Format("{0};{1}", a, i.tud_idTerritorio));

                        // Quantidade de aulas máxima da experiência: quantidade de territórios ligados à ela.
                        tud_cargaHorariaSemanal = territorios.Count;
                        //if (tagsByTud.Sum(p => p.tag_numeroAulas) > tud_cargaHorariaSemanal)
                        //{
                        //    throw new ValidationException(string.Format("A carga horária semanal do componente {0} não deve ser maior que {1}."
                        //        , dicTurmasDisciplinas[tud_id], tud_cargaHorariaSemanal));
                        //}
                    }

                    // Recupera as CLS_TurmaAula que já existem no banco para o docente na turma e período informado
                    // Territórios do saber: se tud_id for relativo a uma experiência, buscará as aulas também dos territórios
                    var aulasBanco = CLS_TurmaAulaBO.SelecionaAulasAtividadesPor_DisicplinasDocentePeriodo(tud_ids, tpc_id, doc_id, banco).Rows.OfType <DataRow>().ToList();

                    // Recupera as disciplinas compartilhadas vigentes para o docente na turma
                    var lstDisciplinaCompartilhada = TUR_TurmaDisciplinaBO.SelectRelacionadaVigenteBy_DisciplinaCompartilhada(tud_id, 0, false, doc_id, banco);

                    var diasNaoUteis = dicDiasNaoUteis.First(i => i.Key == tagsByTud.First().esc_id).Value;

                    var aulasSalvar  = new Dictionary <long[], CLS_TurmaAula>();
                    var aulasExcluir = new List <CLS_TurmaAula>();

                    // esta lista totalizará as aulas que *permanecerão* na semana
                    // (considerando também as que permanecerão inalteradas no banco)
                    // após as gravações das listas aulasSalvar e aulasExcluir
                    var aulasSemana = new List <CLS_TurmaAula>();

                    // variáveis usadas na geração de msgs de erro de vigência dos territórios do saber
                    bool     temTerritorioVigente            = true;
                    bool     temTerritorioVigenteDiaAnterior = true;
                    DateTime vigenciaInicio = inicio;
                    DateTime vigenciaFim    = inicio;

                    #endregion

                    while (inicio <= fim)
                    {
                        foreach (var tag in tagsByTud.Where(t => inicio.DayOfWeek == RetornaDiaSemana(t.tag_diaSemana)))
                        {
                            #region Percorre os dias da semana configurado com aula na agenda

                            if (!diasNaoUteis.Any(d => d.Date == inicio.Date))
                            {
                                #region Territórios do Saber - Recupera dados para verificações

                                //guarda os territórios que efetivamente estão vigentes para a experiência na data em questão
                                var territoriosVigentes = (territorios == null)
                                    ? null
                                    : territorios.Where(t => t.tte_vigenciaInicio.Date <= inicio.Date && (t.tte_vigenciaFim == new DateTime() || t.tte_vigenciaFim.Date >= inicio.Date)).ToList();

                                //guarda as aulas que já estão criadas no banco para os territórios vigentes na data em questão
                                var aulasTerritoriosBanco = (territorios == null)
                                    ? null
                                    : aulasBanco.Where(dr =>
                                                       territoriosVigentes.Select(t => t.tud_idTerritorio).Contains(Convert.ToInt64(dr["tud_id"])) &&
                                                       Convert.ToInt16(dr["tdt_posicao"]) == tag.tdt_posicao &&
                                                       Convert.ToDateTime(dr["tau_data"]) == inicio)
                                                            .Select(dr =>
                                                                    new
                                {
                                    PermiteAlterar = Convert.ToBoolean(dr["PermiteAlterar"]),
                                    Aula           = new CLS_TurmaAulaDAO().DataRowToEntity(dr, new CLS_TurmaAula())
                                })
                                                            .ToList();

                                #endregion

                                #region Recupera aulas existentes no banco de dados

                                var aulaBanco = aulasBanco
                                                .Where(dr =>
                                                       Convert.ToInt64(dr["tud_id"]) == tag.tud_id &&
                                                       Convert.ToInt16(dr["tdt_posicao"]) == tag.tdt_posicao &&
                                                       Convert.ToDateTime(dr["tau_data"]) == inicio &&
                                                       (tag.tud_idRelacionada <= 0 || Convert.ToInt64(dr["tud_idRelacionada"]) == tag.tud_idRelacionada))
                                                .Select(dr =>
                                                        new
                                {
                                    /* Territórios do saber:
                                     * só poderá editar a aula da experiência se ela E as aulas
                                     * correspondentes de TODOS os territórios vigentes na data
                                     * da aula puderem ser editadas também */
                                    PermiteAlterar = Convert.ToBoolean(dr["PermiteAlterar"]) &&
                                                     (territorios == null ||
                                                      !aulasTerritoriosBanco.Any(a => !a.PermiteAlterar)),
                                    Aula = new CLS_TurmaAulaDAO().DataRowToEntity(dr, new CLS_TurmaAula())
                                })
                                                .FirstOrDefault();

                                #endregion

                                temTerritorioVigente = (territorios == null || territoriosVigentes.Count > 0);

                                if (tag.tag_numeroAulas > 0)
                                {
                                    // Há aulas previstas para esse dia da semana
                                    if (aulaBanco == null)
                                    {
                                        #region Cria aula

                                        if (temTerritorioVigente)
                                        {
                                            var nova = new CLS_TurmaAula
                                            {
                                                tud_id          = tag.tud_id,
                                                tau_id          = -1,
                                                tur_id          = tag.tur_id,
                                                tpc_id          = tpc_id,
                                                tau_data        = inicio,
                                                tau_sequencia   = -1,
                                                tau_numeroAulas = tag.tag_numeroAulas,
                                                tau_situacao    = 1,
                                                tdt_posicao     = Convert.ToByte(tag.tdt_posicao > 0 ? tag.tdt_posicao : 1),
                                                usu_id          = usu_id,
                                                IsNew           = true,
                                                tud_tipo        = tag.tud_tipo
                                            };

                                            aulasSalvar.Add(new long[] { tag.tud_id, tag.tud_idRelacionada }, nova);

                                            aulasSemana.Add(nova);
                                        }

                                        #endregion
                                    }
                                    else
                                    {
                                        if (aulaBanco.PermiteAlterar)
                                        {
                                            #region Altera aula existente

                                            if (temTerritorioVigente)
                                            {
                                                aulaBanco.Aula.tau_numeroAulas = tag.tag_numeroAulas;
                                                aulaBanco.Aula.tau_sequencia   = -1;
                                                aulaBanco.Aula.tur_id          = tag.tur_id;
                                                aulaBanco.Aula.IsNew           = false;
                                                aulaBanco.Aula.tud_tipo        = tag.tud_tipo;

                                                aulasSalvar.Add(new long[] { tag.tud_id, tag.tud_idRelacionada }, aulaBanco.Aula);
                                            }

                                            #endregion
                                        }
                                        else
                                        {
                                            gerouTodasAulas = false;
                                        }

                                        aulasSemana.Add(aulaBanco.Aula);
                                    }
                                }
                                // Não há aulas previstas para esse dia da semana
                                // Exclui as aulas que já estão no calendário (quando possível)
                                else if (aulaBanco != null)
                                {
                                    if (aulaBanco.PermiteAlterar)
                                    {
                                        if (territorios == null || territoriosVigentes.Count > 0)
                                        {
                                            aulaBanco.Aula.tur_id = tag.tur_id;
                                            aulasExcluir.Add(aulaBanco.Aula);
                                        }
                                        else
                                        {
                                            // Se não vai excluir a aula, coloca na lista da semana para contabilizar quantidade de aulas.
                                            aulasSemana.Add(aulaBanco.Aula);
                                        }
                                    }
                                    else
                                    {
                                        gerouTodasAulas = false;
                                        // Se não vai excluir a aula, coloca na lista da semana para contabilizar quantidade de aulas.
                                        aulasSemana.Add(aulaBanco.Aula);
                                    }
                                }

                                #region Territorios do saber - msg de vigência

                                if (temTerritorioVigente && !temTerritorioVigenteDiaAnterior)
                                {
                                    string inicioFimTxt = "";

                                    if (territorios != null && (territorios.Any(t => t.tte_vigenciaInicio.Date <= vigenciaInicio.Date) ||
                                                                territorios.Any(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date)))
                                    {
                                        if (!territorios.Any(t => t.tte_vigenciaInicio.Date <= vigenciaInicio.Date))
                                        {
                                            inicioFimTxt = vigenciaInicio.ToString("dd/MM/yyyy") + " - " +
                                                           territorios.Where(t => t.tte_vigenciaInicio.Date > vigenciaInicio.Date)
                                                           .OrderBy(t => t.tte_vigenciaInicio).First()
                                                           .tte_vigenciaInicio.ToString("dd/MM/yyyy");
                                        }

                                        if (territorios.Any(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date))
                                        {
                                            foreach (TUR_TurmaDisciplinaTerritorio tte in territorios.Where(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date)
                                                     .OrderBy(t => t.tte_vigenciaInicio))
                                            {
                                                inicioFimTxt += string.IsNullOrEmpty(inicioFimTxt) ? "" : " e ";
                                                if (tte.tte_vigenciaFim.Date < vigenciaFim.Date)
                                                {
                                                    inicioFimTxt += tte.tte_vigenciaFim.AddDays(1).ToString("dd/MM/yyyy") + " - " +
                                                                    (territorios.Any(t => t.tte_vigenciaInicio > tte.tte_vigenciaFim.Date) ?
                                                                     territorios.Where(t => t.tte_vigenciaInicio > tte.tte_vigenciaFim.Date)
                                                                     .OrderBy(t => t.tte_vigenciaInicio).First()
                                                                     .tte_vigenciaInicio.AddDays(-1).ToString("dd/MM/yyyy") :
                                                                     vigenciaFim.ToString("dd/MM/yyyy"));
                                                }
                                            }
                                        }
                                    }
                                    else
                                    {
                                        inicioFimTxt = vigenciaInicio.ToString("dd/MM/yyyy") + " - " + vigenciaFim.ToString("dd/MM/yyyy");
                                    }

                                    // mostra msg
                                    if (semVigencia.ContainsKey(tud_id))
                                    {
                                        semVigencia[tud_id] = String.Format("{0}, {1}", semVigencia[tud_id], inicioFimTxt);
                                    }
                                    else
                                    {
                                        semVigencia.Add(tud_id, String.Format("{0}: {1}", dicTurmasDisciplinas[tud_id], inicioFimTxt));
                                    }
                                }

                                if (temTerritorioVigente != temTerritorioVigenteDiaAnterior)
                                {
                                    // reinicia contagem
                                    vigenciaInicio = inicio;
                                }

                                temTerritorioVigenteDiaAnterior = temTerritorioVigente;
                                vigenciaFim = inicio;

                                #endregion
                            }

                            #endregion
                        }

                        // Ao final da semana ou do intervalo informado
                        if (inicio.DayOfWeek == DayOfWeek.Sunday || inicio == fim)
                        {
                            #region Grava os dados da semana

                            DateTime dataIniSemana;
                            DateTime dataFimSemana;

                            #region Calcula datas de início e final da semana em questão

                            if (inicio.DayOfWeek == DayOfWeek.Sunday)
                            {
                                dataIniSemana = inicio.AddDays(-7);
                                dataFimSemana = inicio.AddDays(-1);
                            }
                            else
                            {
                                dataIniSemana = inicio.AddDays((int)inicio.DayOfWeek * (-1));
                                dataFimSemana = fim.AddDays(((int)fim.DayOfWeek - (int)DayOfWeek.Saturday) * (-1));
                            }

                            #endregion

                            int quantidadeAulasDaSemana = aulasSalvar.Sum(p => p.Value.tau_numeroAulas);

                            if (dataIniSemana.Date < cap_dataInicio.Date)
                            {
                                // Somar com as aulas que estiverem cadastradas fora do tpc_id.
                                quantidadeAulasDaSemana += CLS_TurmaAulaBO.VerificaSomaNumeroAulasSemana
                                                               (tud_id, dataIniSemana, cap_dataInicio.Date.AddDays(-1),
                                                               banco, Convert.ToByte(tagsByTud.FirstOrDefault().tdt_posicao));
                            }
                            if (dataFimSemana.Date > cap_dataFim.Date)
                            {
                                // Somar com as aulas que estiverem cadastradas fora do tpc_id.
                                quantidadeAulasDaSemana += CLS_TurmaAulaBO.VerificaSomaNumeroAulasSemana
                                                               (tud_id, cap_dataFim.Date.AddDays(1), dataFimSemana,
                                                               banco, Convert.ToByte(tagsByTud.FirstOrDefault().tdt_posicao));
                            }

                            if ((aulasSalvar.Any() || aulasExcluir.Any()) &&
                                DateTime.Today >= dataLimiteLancamento &&
                                tud_tipo != (byte)ACA_CurriculoDisciplinaTipo.DocenciaCompartilhada &&
                                tud_tipo != (byte)ACA_CurriculoDisciplinaTipo.Experiencia &&
                                !semAulasPrevistas.ContainsKey(tud_id) &&
                                !TUR_TurmaDisciplinaAulaPrevistaBO.VerificaLancamento(tud_id, doc_id, tagsByTud.First().tur_id, tagsByTud.First().cal_id))
                            {
                                semAulasPrevistas.Add(tud_id, dicTurmasDisciplinas[tud_id]);
                            }
                            // Se extrapolou a qtde de horas na semana...
                            else if (quantidadeAulasDaSemana > tud_cargaHorariaSemanal)
                            {
                                // ... e há itens nas listas para gravar...
                                if (aulasSalvar.Any() || aulasExcluir.Any())
                                {
                                    // ... gera mensagem de alerta ao usuário
                                    if (ultrapassouCargaHorariaSemanal.ContainsKey(tud_id))
                                    {
                                        ultrapassouCargaHorariaSemanal[tud_id] = String.Format("{0}, {1} - {2}", ultrapassouCargaHorariaSemanal[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy"));
                                    }
                                    else
                                    {
                                        ultrapassouCargaHorariaSemanal.Add(tud_id, String.Format("{0}: {1} - {2}", dicTurmasDisciplinas[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy")));
                                    }
                                }
                            }
                            else
                            {
                                bool gravouTodasTurmaAula   = gerouTodasAulas;
                                bool ultrapassouTerritorios = false;

                                if (aulasExcluir.Any())
                                {
                                    aulasExcluir.ForEach(tau => gravouTodasTurmaAula &= CLS_TurmaAulaBO.Delete(tau, banco, origemLogAula, (byte)LOG_TurmaAula_Alteracao_Tipo.ExclusaoAula, usu_id));
                                }

                                if (aulasSalvar.Any())
                                {
                                    // Ligação da experiência com territórios nas aulas da semana.
                                    List <TurmaAulaTerritorioDados> aulasTerritorios = new List <TurmaAulaTerritorioDados>();
                                    Dictionary <long, int>          dicTerritorios   = new Dictionary <long, int>();

                                    if (tagsByTud.FirstOrDefault().tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia && territorios != null && territorios.Count > 0)
                                    {
                                        // Territórios vigentes dentro da semana.
                                        var territoriosVigentes = territorios.Where
                                                                      (t => t.tte_vigenciaInicio.Date <= dataFimSemana.Date &&
                                                                      (t.tte_vigenciaFim == new DateTime() || t.tte_vigenciaFim.Date >= dataIniSemana.Date)).ToList();

                                        if (aulasSalvar.Any(tau => tau.Value.tau_numeroAulas > territoriosVigentes.Count))
                                        {
                                            ultrapassouTerritorios = true;

                                            if (ultrapassouCargaHorariaSemanal.ContainsKey(tud_id))
                                            {
                                                ultrapassouCargaHorariaSemanal[tud_id] = String.Format("{0}, {1} - {2}", ultrapassouCargaHorariaSemanal[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy"));
                                            }
                                            else
                                            {
                                                ultrapassouCargaHorariaSemanal.Add(tud_id, String.Format("{0}: {1} - {2}", dicTurmasDisciplinas[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy")));
                                            }
                                        }
                                    }

                                    if (!ultrapassouTerritorios)
                                    {
                                        ultrapassouCargaHorariaSemanalTerritorio = ultrapassouCargaHorariaSemanal;

                                        aulasSalvar.ToList()
                                        .ForEach(tau =>
                                        {
                                            gravouTodasTurmaAula &=     /*(tau.Value.tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia ? CLS_TurmaAulaBO.SalvarAulaTerritorio(tau.Value, banco): */
                                                                    tau.Key[1] > 0
                                                            ? CLS_TurmaAulaBO.Save(tau.Value, banco, lstDisciplinaCompartilhada.First(tdr => tdr.tud_id == tau.Key[1]), origemLogAula, (byte)LOG_TurmaAula_Alteracao_Tipo.AlteracaoAula, usu_id)
                                                            : CLS_TurmaAulaBO.Save(tau.Value, banco, origemLogAula, (byte)LOG_TurmaAula_Alteracao_Tipo.AlteracaoAula, usu_id);

                                            if (tagsByTud.FirstOrDefault().tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia && territorios != null && territorios.Count > 0)
                                            {
                                                // Territórios vigentes dentro da semana.
                                                var territoriosVigentes = territorios.Where
                                                                              (t => t.tte_vigenciaInicio.Date <= dataFimSemana.Date &&
                                                                              (t.tte_vigenciaFim == new DateTime() || t.tte_vigenciaFim.Date >= dataIniSemana.Date)).ToList();

                                                // Ligação da experiência com territórios nas aulas da semana.
                                                aulasTerritorios = CLS_TurmaAulaTerritorioBO.SelecionaAulasTerritorioPorExperiencia
                                                                       (tud_id, dataIniSemana, dataFimSemana, banco);

                                                dicTerritorios =
                                                    (from TUR_TurmaDisciplinaTerritorio item in
                                                     territoriosVigentes.Where(t => !aulasTerritorios.Any(a => a.tud_idTerritorio == t.tud_idTerritorio &&
                                                                                                          a.tau_idExperiencia != tau.Value.tau_id))
                                                     select new
                                                {
                                                    tud_id = item.tud_idTerritorio
                                                    ,
                                                    tud_nomeTerritorio = item.tud_nomeTerritorio
                                                    ,
                                                    qtAulas = (from TurmaAulaTerritorioDados iAula in aulasTerritorios
                                                               where
                                                               iAula.tud_idExperiencia == item.tud_idExperiencia &&
                                                               iAula.tud_idTerritorio == item.tud_idTerritorio
                                                               select iAula.tud_idTerritorio).Count()
                                                }).OrderBy(p => p.tud_nomeTerritorio).ToDictionary(p => p.tud_id, p => p.qtAulas);

                                                //Se for uma edição de aula então pega apenas as aulas ligadas à ela
                                                aulasTerritorios = aulasTerritorios.Where(a => a.tud_idExperiencia == tau.Value.tud_id &&
                                                                                          a.tau_idExperiencia == tau.Value.tau_id).ToList();

                                                //Valida a carga horária da experiência
                                                if (!dicTerritorios.Any() && !aulasTerritorios.Any())
                                                {
                                                    gravouTodasTurmaAula &= false;

                                                    // ... gera mensagem de alerta ao usuário
                                                    if (ultrapassouCargaHorariaSemanalTerritorio.ContainsKey(tud_id))
                                                    {
                                                        ultrapassouCargaHorariaSemanalTerritorio[tud_id] = String.Format("{0}, {1} - {2}", ultrapassouCargaHorariaSemanalTerritorio[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy"));
                                                    }
                                                    else
                                                    {
                                                        ultrapassouCargaHorariaSemanalTerritorio.Add(tud_id, String.Format("{0}: {1} - {2}", dicTurmasDisciplinas[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy")));
                                                    }
                                                }
                                                else
                                                {
                                                    // Verifica ligações com territórios quando a aula é de experiência.
                                                    CLS_TurmaAulaBO.CriaLigacoesTerritorios(usu_id, origemLogAula, tau.Value, banco, aulasTerritorios, dicTerritorios);
                                                }
                                            }
                                        });

                                        ultrapassouCargaHorariaSemanal = ultrapassouCargaHorariaSemanalTerritorio;
                                    }
                                }
                                gerouTodasAulas &= gravouTodasTurmaAula;
                            }

                            aulasSalvar.Clear();
                            aulasExcluir.Clear();
                            aulasSemana.Clear();

                            #endregion
                        }

                        inicio = inicio.AddDays(1);
                    }

                    #region Territorios do saber - msg de vigência

                    if (!temTerritorioVigente)
                    {
                        string inicioFimTxt = "";

                        if (territorios != null && (territorios.Any(t => t.tte_vigenciaInicio.Date <= vigenciaInicio.Date) ||
                                                    territorios.Any(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date)))
                        {
                            if (!territorios.Any(t => t.tte_vigenciaInicio.Date <= vigenciaInicio.Date))
                            {
                                inicioFimTxt = vigenciaInicio.ToString("dd/MM/yyyy") + " - " +
                                               territorios.Where(t => t.tte_vigenciaInicio.Date > vigenciaInicio.Date)
                                               .OrderBy(t => t.tte_vigenciaInicio).First()
                                               .tte_vigenciaInicio.ToString("dd/MM/yyyy");
                            }

                            if (territorios.Any(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date))
                            {
                                foreach (TUR_TurmaDisciplinaTerritorio tte in territorios.Where(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date)
                                         .OrderBy(t => t.tte_vigenciaInicio))
                                {
                                    inicioFimTxt += string.IsNullOrEmpty(inicioFimTxt) ? "" : " e ";
                                    if (tte.tte_vigenciaFim.Date < vigenciaFim.Date)
                                    {
                                        inicioFimTxt += tte.tte_vigenciaFim.AddDays(1).ToString("dd/MM/yyyy") + " - " +
                                                        (territorios.Any(t => t.tte_vigenciaInicio > tte.tte_vigenciaFim.Date) ?
                                                         territorios.Where(t => t.tte_vigenciaInicio > tte.tte_vigenciaFim.Date)
                                                         .OrderBy(t => t.tte_vigenciaInicio).First()
                                                         .tte_vigenciaInicio.AddDays(-1).ToString("dd/MM/yyyy") :
                                                         vigenciaFim.ToString("dd/MM/yyyy"));
                                    }
                                }
                            }
                        }
                        else
                        {
                            inicioFimTxt = vigenciaInicio.ToString("dd/MM/yyyy") + " - " + vigenciaFim.ToString("dd/MM/yyyy");
                        }

                        // Entra aqui somente qdo não há vigência na última data com aula para gerar
                        if (semVigencia.ContainsKey(tud_id))
                        {
                            semVigencia[tud_id] = String.Format("{0}, {1}", semVigencia[tud_id], inicioFimTxt);
                        }
                        else
                        {
                            semVigencia.Add(tud_id, String.Format("{0}: {1}", dicTurmasDisciplinas[tud_id], inicioFimTxt));
                        }
                    }

                    #endregion

                    bool gravouTodas = gerouTodasAulas;
                    tagsByTud.ForEach(tag => gravouTodas &= Save(tag, banco));
                    gerouTodasAulas &= gravouTodas;

                    CLS_TurmaAulaBO.AtualizarSequenciaAulasPorTurmaDisciplina(tud_id, banco);

                    // Caso o fechamento seja automático, grava na fila de processamento.
                    if (tagsByTud.First().fav_fechamentoAutomatico&& tagsByTud.First().tud_tipo != (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia && tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
                    {
                        CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(tud_id, tpc_id, banco);
                    }
                }
                catch (Exception ex)
                {
                    outrosErros.Add(tud_id, ex);
                    banco.Close(ex);
                }
                finally
                {
                    if (banco.ConnectionIsOpen)
                    {
                        banco.Close();
                    }
                }
            }

            return(true);
        }
Exemplo n.º 6
0
        /// <summary>
        /// Salva as entidades turmaAula e TurmaAulaAluno nas listas - com transação.
        /// </summary>
        /// <param name="listTurmaAulaAluno">Lista de entidades CLS_TurmaAulaAluno</param>
        /// <param name="listTurmaAula">LIsta de entidades CLS_TurmaAula</param>
        /// <param name="tur_id">ID da turma</param>
        /// <param name="tud_id">ID da disciplina que está sendo salva as frequências</param>
        /// <param name="tdt_posicao">Posição do docente logado no sistema</param>
        /// <param name="entityTurma">Turma.</param>
        /// <param name="entityFormatoAvaliacao">Formato de avaliação.</param>
        /// <param name="entityCurriculoPeriodo">CurriculoPeriodo.</param>
        /// <param name="banco">Transação com banco de dados aberta</param>
        /// <returns></returns>
        internal static bool Save
        (
            List <CLS_TurmaAulaAluno> listTurmaAulaAluno
            , List <CLS_TurmaAula> listTurmaAula
            , long tur_id
            , long tud_id
            , byte tdt_posicao
            , TUR_Turma entityTurma
            , ACA_FormatoAvaliacao entityFormatoAvaliacao
            , ACA_CurriculoPeriodo entityCurriculoPeriodo
            , TalkDBTransaction banco
            , Guid usu_id        = new Guid()
            , byte origemLogAula = 0
            , byte tipoLogAula   = 0
            , Guid ent_id        = new Guid()
        )
        {
            string tau_ids = string.Join(",",
                                         (from CLS_TurmaAula item in listTurmaAula select item.tau_id.ToString()).
                                         ToArray());

            // Recupera a lista de entidades CLS_TurmaAulaAluno para verificar se ela já existe.
            List <CLS_TurmaAulaAluno> listaTurmaAulaAluno = new CLS_TurmaAulaAlunoDAO {
                _Banco = banco
            }
            .SelectBy_Disciplina_Aulas(tud_id, tau_ids);

            DataTable dtTurmaAulaAluno = CLS_TurmaAulaAluno.TipoTabela_TurmaAulaAluno();
            List <LOG_TurmaAula_Alteracao> listLogAula = new List <LOG_TurmaAula_Alteracao>();

            object lockObject = new object();

            Parallel.ForEach
            (
                listTurmaAulaAluno,
                entityTurmaAulaAluno =>
            {
                // Busca se a entidade já existe na lista.
                CLS_TurmaAulaAluno entAux =
                    listaTurmaAulaAluno.Find(p =>
                                             p.tud_id == entityTurmaAulaAluno.tud_id &&
                                             p.tau_id == entityTurmaAulaAluno.tau_id &&
                                             p.alu_id == entityTurmaAulaAluno.alu_id &&
                                             p.mtu_id == entityTurmaAulaAluno.mtu_id &&
                                             p.mtd_id == entityTurmaAulaAluno.mtd_id
                                             );

                if (entAux != null)
                {
                    entityTurmaAulaAluno.IsNew        = entAux.IsNew;
                    entityTurmaAulaAluno.taa_anotacao = entAux.taa_anotacao;

                    entityTurmaAulaAluno.usu_idDocenteAlteracao = entAux.usu_idDocenteAlteracao;
                }

                Validate(entityTurmaAulaAluno, listTurmaAula);

                if (entityTurmaAulaAluno.Validate())
                {
                    lock (lockObject)
                    {
                        DataRow dr = dtTurmaAulaAluno.NewRow();
                        dtTurmaAulaAluno.Rows.Add(TurmaAulaAlunoToDataRow(entityTurmaAulaAluno, dr));
                    }
                }
                else
                {
                    throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entityTurmaAulaAluno));
                }
            }
            );

            // Salva os dados de todos os alunos na tabela CLS_TurmaAulaAluno
            SalvaFrequenciaAlunos(dtTurmaAulaAluno, banco);

            // Verifica se a entidade recebida por parâmetro foi alimentada, se não foi, dá o GetEntity.
            TUR_Turma turma = entityTurma ?? TUR_TurmaBO.GetEntity(new TUR_Turma {
                tur_id = tur_id
            }, banco);
            ACA_FormatoAvaliacao formatoAvaliacao = entityFormatoAvaliacao ?? ACA_FormatoAvaliacaoBO.GetEntity(new ACA_FormatoAvaliacao {
                fav_id = turma.fav_id
            }, banco);
            ACA_CurriculoPeriodo entityCrp = entityCurriculoPeriodo ?? ACA_CurriculoPeriodoBO.SelecionaPorTurmaTipoNormal(turma.tur_id, GestaoEscolarUtilBO.MinutosCacheLongo);

            List <TUR_TurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, banco, GestaoEscolarUtilBO.MinutosCacheLongo);

            TUR_TurmaDisciplina entDisciplinarincipal =
                listaDisciplinas.Find(p => p.tud_tipo == (byte)TurmaDisciplinaTipo.DisciplinaPrincipal);

            // Se não for para lançar na disciplina global, e a turma possuir uma disc. principal,
            // só poderá salvar na disciplina principal.
            bool validarDiscPrincipal =
                (!(turma.tur_docenteEspecialista && formatoAvaliacao.fav_planejamentoAulasNotasConjunto)) &&
                (entDisciplinarincipal != null) && (formatoAvaliacao.fav_tipoApuracaoFrequencia != (byte)ACA_FormatoAvaliacaoTipoApuracaoFrequencia.Dia &&
                                                    entityCrp.crp_controleTempo != (byte)ACA_CurriculoPeriodoControleTempo.Horas);

            DateTime dataLogAula = DateTime.Now;

            foreach (CLS_TurmaAula entityTurmaAula in listTurmaAula)
            {
                // Se for pra validar a disc. principal, só pode lançar frequência nela.
                if (validarDiscPrincipal && (entDisciplinarincipal.tud_id != entityTurmaAula.tud_id))
                {
                    throw new ValidationException("A frequência dessa turma só pode ser lançada para o(a) " + CustomResource.GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA") + entDisciplinarincipal.tud_nome + ".");
                }

                if (origemLogAula > 0)
                {
                    LOG_TurmaAula_Alteracao entLogAula = new LOG_TurmaAula_Alteracao
                    {
                        tud_id     = entityTurmaAula.tud_id,
                        tau_id     = entityTurmaAula.tau_id,
                        usu_id     = usu_id,
                        lta_origem = origemLogAula,
                        lta_tipo   = tipoLogAula,
                        lta_data   = dataLogAula
                    };

                    listLogAula.Add(entLogAula);
                }
            }

            //Salva os logs de alteração de aula
            LOG_TurmaAula_AlteracaoBO.SalvarEmLote(listLogAula, banco);

            // Atualiza o campo efetivado da aula.
            CLS_TurmaAulaBO.AtualizarEfetivado(listTurmaAula, banco);

            // Caso o fechamento seja automático, grava na fila de processamento.
            if (formatoAvaliacao.fav_fechamentoAutomatico && listTurmaAula.Count > 0 && listTurmaAula[0].tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
            {
                CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(tud_id, listTurmaAula[0].tpc_id, banco);
            }

            if (listTurmaAula.Any() && dtTurmaAulaAluno.Rows.Count > 0 && HttpContext.Current != null)
            {
                // Limpa o cache do fechamento
                try
                {
                    string chave  = string.Empty;
                    int    tpc_id = listTurmaAula[0].tpc_id;
                    List <ACA_Avaliacao> avaliacao = ACA_AvaliacaoBO.GetSelectBy_FormatoAvaliacaoPeriodo(turma.fav_id, tpc_id);

                    if (avaliacao.Any())
                    {
                        int ava_id = avaliacao.First().ava_id;
                        if (tud_id > 0)
                        {
                            chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodo(tud_id, turma.fav_id, ava_id, string.Empty);
                            CacheManager.Factory.RemoveByPattern(chave);

                            chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodoFiltroDeficiencia(tud_id, turma.fav_id, ava_id, string.Empty);
                            CacheManager.Factory.RemoveByPattern(chave);
                        }
                        else
                        {
                            chave = MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Periodo(tur_id, turma.fav_id, ava_id);
                            HttpContext.Current.Cache.Remove(chave);
                        }
                    }
                }
                catch
                { }
            }

            return(true);
        }
Exemplo n.º 7
0
        /// <summary>
        /// Processa os protocolos informados.
        /// </summary>
        /// <param name="ltProtocolo">Lista de protocolos em processamento.</param>
        /// <param name="tentativasProtocolo">Quantidade máxima de tentativas para processar protocolos.</param>
        /// <returns></returns>
        public static bool ProcessarProtocoloCompensacao(List <DCL_Protocolo> ltProtocolo, int tentativasProtocolo)
        {
            DataTable dtProtocolo = DCL_Protocolo.TipoTabela_Protocolo();

            foreach (DCL_Protocolo protocolo in ltProtocolo.Where(pro => pro.pro_tentativa > tentativasProtocolo))
            {
                protocolo.pro_statusObservacao = String.Format("Número máximo ({0}) de tentativas de processamento deste protocolo foram excedidas. Erro: {1}"
                                                               , tentativasProtocolo, protocolo.pro_statusObservacao);
                protocolo.pro_status     = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao;
                protocolo.tur_id         = -1;
                protocolo.tud_id         = -1;
                protocolo.tau_id         = -1;
                protocolo.pro_qtdeAlunos = -1;
                dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
            }

            foreach (DCL_Protocolo protocolo in ltProtocolo.Where(pro => pro.pro_tentativa <= tentativasProtocolo))
            {
                // Abre uma transação para cada protocolo dentro do laço.
                // Assim é possível processar o próximo protocolo, mesmo que o atual esteja com erro.
                TalkDBTransaction bancoSincronizacao = new CLS_TurmaAulaDAO()._Banco.CopyThisInstance();
                bancoSincronizacao.Open(IsolationLevel.ReadCommitted);
                bool processou = false;

                try
                {
                    if (protocolo.pro_tentativa <= tentativasProtocolo)
                    {
                        JObject json = JObject.Parse(protocolo.pro_pacote);

                        JArray compensacoes = ((JArray)json.SelectToken("CompensacaoFalta") ?? new JArray());

                        foreach (JObject compensacao in compensacoes)
                        {
                            long tud_id = Convert.ToInt64(compensacao.SelectToken("tud_id"));

                            ACA_FormatoAvaliacao formatoAvaliacao = ACA_FormatoAvaliacaoBO.CarregarPorTud(tud_id);
                            ACA_CalendarioAnual  cal = ACA_CalendarioAnualBO.SelecionaPorTurmaDisciplina(tud_id, bancoSincronizacao);

                            // apenas protocolos de turmas ativas e do ano letivo corrente podem ser processados
                            if (!DCL_ProtocoloBO.PodeProcessarProtocolo(0, tud_id))
                            {
                                throw new ValidationException("O protocolo pertence a uma turma que não esta ativa ou de um ano letivo diferente do corrente, não pode ser processado!");
                            }

                            int cpa_id = Convert.ToInt32(compensacao.SelectToken("cpa_id"));
                            int quantidadeAulasCompensadas = Convert.ToInt32(compensacao.SelectToken("cpa_quantidadeAulasCompensadas"));

                            DateTime cpa_dataAlteracao = Convert.ToDateTime(compensacao.SelectToken("cpa_dataAlteracao"));

                            CLS_CompensacaoAusencia compensacaoAusencia;

                            long pro_protocoloCriacao = (long)(compensacao.GetValue("pro_protocolo", StringComparison.OrdinalIgnoreCase) ?? "0");
                            if (cpa_id > 0 || pro_protocoloCriacao <= 0)
                            {
                                compensacaoAusencia = new CLS_CompensacaoAusencia
                                {
                                    tud_id = tud_id,
                                    cpa_id = cpa_id
                                };
                                GetEntity(compensacaoAusencia, bancoSincronizacao);
                            }
                            else
                            {
                                List <DCL_Protocolo> protocoloCriacaoCompensacao = DCL_ProtocoloBO.SelectBy_Protocolos(pro_protocoloCriacao.ToString());
                                Guid pro_idCriacao = protocoloCriacaoCompensacao.Count() > 0 ? protocoloCriacaoCompensacao[0].pro_id : Guid.Empty;
                                compensacaoAusencia = SelectByDisciplinaProtocolo(tud_id, pro_idCriacao);
                                if (!compensacaoAusencia.IsNew)
                                {
                                    compensacaoAusencia.pro_id = protocolo.pro_id;
                                }
                            }

                            if (compensacaoAusencia.IsNew)
                            {
                                compensacaoAusencia.cpa_id          = -1;
                                compensacaoAusencia.cpa_dataCriacao = DateTime.Now;
                                compensacaoAusencia.pro_id          = protocolo.pro_id;
                            }
                            else if (!compensacaoAusencia.IsNew && (cpa_dataAlteracao < compensacaoAusencia.cpa_dataAlteracao))
                            {
                                throw new ValidationException("Compensação existe e foi alterada mais recentemente.");
                            }

                            compensacaoAusencia.tpc_id = Convert.ToInt32(compensacao.SelectToken("tpc_id"));
                            compensacaoAusencia.cpa_quantidadeAulasCompensadas = quantidadeAulasCompensadas;
                            compensacaoAusencia.cpa_atividadesDesenvolvidas    = Convert.ToString(compensacao.SelectToken("cpa_atividadesDesenvolvidas"));
                            compensacaoAusencia.cpa_situacao      = Convert.ToInt16(compensacao.SelectToken("cpa_situacao"));
                            compensacaoAusencia.cpa_dataAlteracao = DateTime.Now;

                            if (compensacaoAusencia.cpa_situacao != 3)
                            {
                                JArray arrayAlunos = ((JArray)compensacao.SelectToken("AlunosCompensados") ?? new JArray());
                                List <CLS_CompensacaoAusenciaAluno> listaAlunos = new List <CLS_CompensacaoAusenciaAluno>();
                                foreach (JObject jsonAluno in arrayAlunos)
                                {
                                    int alu_id = Convert.ToInt32(jsonAluno.SelectToken("alu_id"));
                                    MTR_MatriculaTurmaDisciplina matricula = MTR_MatriculaTurmaDisciplinaBO.BuscarPorAlunoTurmaDisciplina(alu_id, tud_id, bancoSincronizacao);

                                    CLS_CompensacaoAusenciaAluno compensacaoAluno = new CLS_CompensacaoAusenciaAluno
                                    {
                                        tud_id = tud_id,
                                        cpa_id = compensacaoAusencia.cpa_id,
                                        alu_id = alu_id,
                                        mtu_id = matricula.mtu_id,
                                        mtd_id = matricula.mtd_id
                                    };

                                    CLS_CompensacaoAusenciaAlunoBO.GetEntity(compensacaoAluno);

                                    if (compensacaoAluno.IsNew)
                                    {
                                        compensacaoAluno.caa_dataCriacao = DateTime.Now;
                                    }

                                    compensacaoAluno.caa_situacao      = 1;
                                    compensacaoAluno.caa_dataAlteracao = DateTime.Now;


                                    listaAlunos.Add(compensacaoAluno);
                                }

                                processou = Save(compensacaoAusencia, listaAlunos, formatoAvaliacao.fav_fechamentoAutomatico, cal.cal_id, bancoSincronizacao);
                            }
                            else
                            {
                                // persistindo os dados.
                                processou = true;
                                // Caso o fechamento seja automático, grava na fila de processamento.
                                if (formatoAvaliacao.fav_fechamentoAutomatico && compensacaoAusencia.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, new Guid()))
                                {
                                    processou &= CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(compensacaoAusencia.tud_id, compensacaoAusencia.tpc_id, bancoSincronizacao);
                                }
                                processou &= Delete(compensacaoAusencia, bancoSincronizacao);
                            }
                        }
                    }


                    // Processou com sucesso.
                    protocolo.pro_statusObservacao = String.Format("Protocolo processado com sucesso ({0}).",
                                                                   DateTime.Now.ToString("dd/MM/yyyy HH:mm"));
                    protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComSucesso;
                    dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
                }
                catch (ArgumentException ex)
                {
                    // Se ocorrer uma excessão de validação, guardar novo status.
                    protocolo.pro_status           = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao;
                    protocolo.pro_statusObservacao = ex.Message;
                    protocolo.tur_id         = -1;
                    protocolo.tud_id         = -1;
                    protocolo.tau_id         = -1;
                    protocolo.pro_qtdeAlunos = -1;
                    dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
                    bancoSincronizacao.Close(ex);
                }
                catch (ValidationException ex)
                {
                    // Se ocorrer uma excessão de validação, guardar novo status.
                    protocolo.pro_status           = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao;
                    protocolo.pro_statusObservacao = ex.Message;
                    protocolo.tur_id         = -1;
                    protocolo.tud_id         = -1;
                    protocolo.tau_id         = -1;
                    protocolo.pro_qtdeAlunos = -1;
                    dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
                    bancoSincronizacao.Close(ex);
                }
                catch (Exception ex)
                {
                    // Se ocorrer uma excessão de erro, guardar novo status.
                    protocolo.pro_status           = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErro;
                    protocolo.pro_statusObservacao = ex.Message;
                    protocolo.tur_id         = -1;
                    protocolo.tud_id         = -1;
                    protocolo.tau_id         = -1;
                    protocolo.pro_qtdeAlunos = -1;
                    dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow()));
                    bancoSincronizacao.Close(ex);
                }
                finally
                {
                    if (bancoSincronizacao.ConnectionIsOpen)
                    {
                        bancoSincronizacao.Close();
                    }
                }
            }

            DCL_ProtocoloBO.AtualizaProtocolos(dtProtocolo);

            return(true);
        }
Exemplo n.º 8
0
        /// <summary>
        /// Override do Save passando o banco - salva tambem a tabela CLS_CompensacaoAusenciaAluno
        /// </summary>
        /// <param name="entity">Entidade a ser salva</param>
        /// <param name="lista">Lista de CLS_CompensacaoAusenciaAluno a ser salva</param>
        /// <param name="fechamentoAutomatico">Indica se o fechamento é automático.</param>
        /// <param name="banco">Transação com banco</param>
        /// <returns>Se salvou com sucesso</returns>
        public static bool Save(CLS_CompensacaoAusencia entity, List <CLS_CompensacaoAusenciaAluno> lista, bool fechamentoAutomatico, int cal_id, TalkDBTransaction banco)
        {
            // permite cadatrar compensacao apenas para o ultimo periodo aberto,
            // o metodo ja retorna os periodos abertos ordenados do mais recente para o mais antigo
            List <sComboPeriodoCalendario> dtPeriodos = ACA_TipoPeriodoCalendarioBO.SelecionaPor_PeriodoVigente_EventoEfetivacaoVigente(-1, entity.tud_id, -1, Guid.Empty, true);

            if (dtPeriodos.Count > 0 && dtPeriodos.Any(p => p.tpc_id == entity.tpc_id))
            {
                //validacoes
                DataTable dt = MTR_MatriculaTurmaDisciplinaBO.SelecionaAtivosCompensacaoAusencia(
                    entity.tud_id,
                    entity.tpc_id,
                    0,
                    entity.cpa_id
                    );
                dt.PrimaryKey = new DataColumn[1] {
                    dt.Columns["alu_id"]
                };

                TUR_TurmaDisciplina turmaDisciplina = TUR_TurmaDisciplinaBO.GetEntity(new TUR_TurmaDisciplina {
                    tud_id = entity.tud_id
                });
                // se for disciplina especial
                if (turmaDisciplina.tud_disciplinaEspecial
                    // e o docente do tipo especial tem permissao de editar a compensacao
                    && CFG_PermissaoDocenteBO.SelecionaPermissaoModulo((byte)EnumTipoDocente.Especial, (byte)EnumModuloPermissao.Compensacoes).Any(p => p.pdc_permissaoEdicao))
                {
                    // adiciono na lista de validacao os aluno especiais
                    DataTable dtEspecial = MTR_MatriculaTurmaDisciplinaBO.SelecionaAtivosCompensacaoAusenciaFiltroDeficiencia(
                        -1,
                        entity.tud_id,
                        entity.tpc_id,
                        0,
                        EnumTipoDocente.Especial,
                        entity.cpa_id);
                    dt.Merge(dtEspecial, false, MissingSchemaAction.AddWithKey);
                }

                bool   valida       = true;
                string msgValidacao = "";

                if (turmaDisciplina.tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia)
                {
                    if (!TUR_TurmaDisciplinaTerritorioBO.VerificaOferecimentoExperienciaBimestre(turmaDisciplina.tud_id, cal_id, entity.tpc_id))
                    {
                        valida        = false;
                        msgValidacao += "A experiência não possui territórios vigentes no bimestre.";
                    }
                }

                // caso exista alguma compensação já criada pro aluno
                // valida se pode existir alguma outra.
                foreach (CLS_CompensacaoAusenciaAluno cpaa in lista)
                {
                    var results = from row in dt.AsEnumerable()
                                  where row.Field <Int64>("alu_id") == cpaa.alu_id
                                  select row;

                    if (results.Count() > 0)
                    {
                        DataTable aux = results.CopyToDataTable();
                        int       totalFaltasCompensar = Convert.ToInt32(aux.Rows[0]["TotalFaltasCompensar"]);
                        if (entity.cpa_quantidadeAulasCompensadas > totalFaltasCompensar)
                        {
                            valida        = false;
                            msgValidacao += String.Format("Aluno(a) {0} não pode ter essa quantidade de ausências compensadas. </br>", aux.Rows[0]["pes_nome"].ToString());
                        }
                    }
                    else
                    {
                        valida = false;
                        ACA_Aluno aluno = ACA_AlunoBO.GetEntity(new ACA_Aluno {
                            alu_id = cpaa.alu_id
                        });
                        PES_Pessoa pes = PES_PessoaBO.GetEntity(new PES_Pessoa {
                            pes_id = aluno.pes_id
                        });
                        msgValidacao += String.Format("Aluno(a) {0} não pode ter ausências compensadas nos bimestres em que não estava na turma. </br>", pes.pes_nome);
                    }
                }
                if (!valida)
                {
                    throw new ValidationException(msgValidacao);
                }

                // Salva CLS_CompensacaoAusencia
                if (!Save(entity, banco))
                {
                    throw new Exception("Erro ao tentar salvar compensação de ausência.");
                }

                // Caso o fechamento seja automático, grava na fila de processamento.
                if (fechamentoAutomatico && entity.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, new Guid()))
                {
                    CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(entity.tud_id, entity.tpc_id, banco);
                }

                List <CLS_CompensacaoAusenciaAluno> listaBanco = CLS_CompensacaoAusenciaAlunoBO.SelectByCpa_id(entity.cpa_id, entity.tud_id);

                foreach (CLS_CompensacaoAusenciaAluno item in lista)
                {
                    CLS_CompensacaoAusenciaAluno ent = listaBanco.Find(p => p.tud_id == item.tud_id &&
                                                                       p.cpa_id == entity.cpa_id &&
                                                                       p.alu_id == item.alu_id &&
                                                                       p.mtd_id == item.mtd_id &&
                                                                       p.mtu_id == item.mtu_id);

                    if (ent != null)
                    {
                        // Achou na lista que vem no banco, altera.
                        ent.IsNew = false;
                        CLS_CompensacaoAusenciaAlunoBO.Save(ent, banco);

                        // Remove o registro da lista do banco para restar somente os que serao excluidos.
                        listaBanco.Remove(ent);
                    }
                    else
                    {
                        // Não achou na lista do banco, inclui.
                        item.cpa_id = entity.cpa_id;
                        CLS_CompensacaoAusenciaAlunoBO.GetEntity(item, banco);
                        if (item.caa_situacao == 3)
                        {
                            item.caa_situacao = 1;
                            item.IsNew        = false;
                        }
                        else
                        {
                            item.IsNew = true;
                        }
                        CLS_CompensacaoAusenciaAlunoBO.Save(item, banco);
                    }
                }

                if (listaBanco.Count > 0)
                {
                    foreach (CLS_CompensacaoAusenciaAluno item in listaBanco)
                    {
                        CLS_CompensacaoAusenciaAlunoBO.Delete(item, banco);
                    }
                }
            }
            else
            {
                throw new ValidationException("Não existe evento de fechamento do bimestre aberto para realizar o lançamento.");
            }
            return(true);
        }