Пример #1
0
        /// <summary>
        /// Carrega os alunos da turma.
        /// </summary>
        /// <param name="tur_id">Id da turma.</param>
        private void CarregarAlunosTurma(long tur_id)
        {
            VS_ListaAlunos       = CLS_AlunoAvaliacaoTurmaDisciplinaBO.SelecionarAlunosTurma(tur_id, OrdenacaoDados, ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_NOTAS, __SessionWEB.__UsuarioWEB.Usuario.ent_id), true);
            rptAlunos.DataSource = VS_ListaAlunos;
            rptAlunos.DataBind();

            updDadosAluno.Update();
        }
Пример #2
0
        /// <summary>
        /// Retorno dos dados.
        /// </summary>
        protected void UCAlunoEfetivacaoObservacaoGeral_ReturnValues(CLS_AlunoAvaliacaoTurmaObservacao entityObservacaoSelecionada, List <CLS_AlunoAvaliacaoTurmaDisciplina> listaAtualizacaoEfetivacao, byte resultado, List <MTR_MatriculaTurmaDisciplina> listaMatriculaTurmaDisciplina)
        {
            try
            {
                // Carrega os alunos da turma.
                List <CLS_AlunoAvaliacaoTurDis_DadosAlunos> listaAlunos          = VS_ListaAlunos;
                CLS_AlunoAvaliacaoTurDis_DadosAlunos        dadoAlunoSelecionado = CLS_AlunoAvaliacaoTurmaDisciplinaBO.SelecionarAlunosTurma(VS_tur_id, OrdenacaoDados, ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_EVENTO_EFETIVACAO_NOTAS, __SessionWEB.__UsuarioWEB.Usuario.ent_id), true, VS_alu_idSelecionado).FirstOrDefault();
                if (listaAlunos.Any(p => p.alu_id == VS_alu_idSelecionado))
                {
                    int i = listaAlunos.FindIndex(p => p.alu_id == VS_alu_idSelecionado);
                    listaAlunos[i] = dadoAlunoSelecionado;
                }
                rptAlunos.DataSource = listaAlunos;
                rptAlunos.DataBind();
                updDadosAluno.Update();
                VS_ListaAlunos = listaAlunos;

                foreach (RepeaterItem item in rptAlunos.Items)
                {
                    HiddenField hdnAluId = (HiddenField)item.FindControl("hdnAluId");
                    if (Convert.ToInt64(hdnAluId.Value) == VS_alu_idSelecionado)
                    {
                        // Adiciona o estilo ao item selecionado.
                        HtmlTableRow trNomeAlunoAtivo = (HtmlTableRow)item.FindControl("trNomeAluno");
                        trNomeAlunoAtivo.Attributes.Add("class", "aluno-selecionado");
                    }
                }

                updDadosAluno.Update();
            }
            catch (Exception ex)
            {
                divResultados.Visible = false;
                ApplicationWEB._GravaErro(ex);
                lblMensagem.Text = UtilBO.GetErroMessage(RetornaValorResource("ErroCarregarSistema"), UtilBO.TipoMensagem.Erro);
            }
        }
        /// <summary>
        /// O método salva as observações para conselho pedagógico.
        /// </summary>
        /// <param name="tur_id">ID da turma.</param>
        /// <param name="alu_id">ID do aluno.</param>
        /// <param name="mtu_id">ID da matrícula turma do aluno.</param>
        /// <param name="fav_id">ID do formato de avaliação.</param>
        /// <param name="ava_id">ID da avaliação.</param>
        /// <param name="ltObservacao">Lista de observações.</param>
        /// <param name="banco">Banco</param>
        /// <param name="ent_id">Id da entidade do usuário logado.</param>
        /// <returns></returns>
        public static bool SalvarObservacao
        (
            long tur_id,
            long alu_id,
            int mtu_id,
            long[] tud_ids,
            List <CLS_AlunoAvaliacaoTurmaObservacao> listaObservacao,
            List <CLS_AlunoAvaliacaoTurma> listaAlunoAvaliacaoTurma,
            List <CLS_AlunoAvaliacaoTurmaDisciplina> listaAlunoAvaliacaoTurmaDisciplina,
            List <ACA_AlunoAnotacao> listaAlunoAnotacao,
            bool permiteEditarResultadoFinal,
            Guid usu_idLogado,
            byte resultado,
            DateTime dataUltimaAlteracaoObservacao,
            DateTime dataUltimaAlteracaoNotaFinal,
            ACA_FormatoAvaliacao entFormatoAvaliacao,
            List <CLS_AvaliacaoTurDisc_Cadastro> listaDisciplina,
            List <MTR_MatriculaTurmaDisciplina> listaMatriculaTurmaDisciplina,
            int tamanhoMaximoKB,
            string[] TiposArquivosPermitidos,
            ref List <CLS_AlunoAvaliacaoTurmaDisciplina> listaAtualizacaoEfetivacao,
            Guid ent_id,
            IDictionary <int, int> dicAvaTpc,
            List <CLS_AlunoAvaliacaoTurmaObservacaoBO.DadosAlunoObservacao> listaDadosPeriodo
        )
        {
            TalkDBTransaction banco = new CLS_AlunoAvaliacaoTurmaObservacaoDAO()._Banco.CopyThisInstance();

            banco.Open(IsolationLevel.ReadCommitted);

            List <AlunoFechamentoPendencia> FilaProcessamento = new List <AlunoFechamentoPendencia>();
            int tpc_idUltimoPeriodo = (dicAvaTpc.Count() > 0 ? dicAvaTpc.Max(p => p.Value) : 0);

            try
            {
                foreach (CLS_AlunoAvaliacaoTurmaObservacao observacao in listaObservacao)
                {
                    observacao.usu_idAlteracao = usu_idLogado;
                    Save(observacao, banco);
                }

                foreach (CLS_AlunoAvaliacaoTurma alunoAvaliacaoTurma in listaAlunoAvaliacaoTurma)
                {
                    CLS_AlunoAvaliacaoTurmaBO.Save(alunoAvaliacaoTurma, banco);
                }


                object lockObject = new object();

                DataTable dtAlunoAvaliacaoTurmaDisciplina = CLS_AlunoAvaliacaoTurmaDisciplina.TipoTabela_AlunoAvaliacaoTurmaDisciplina();
                if (listaAlunoAvaliacaoTurmaDisciplina.Any())
                {
                    Parallel.ForEach
                    (
                        listaAlunoAvaliacaoTurmaDisciplina,
                        alunoAvaliacaoTurmaDisciplina =>
                    {
                        lock (lockObject)
                        {
                            DataRow drAlunoAvaliacaoTurmaDisciplina = dtAlunoAvaliacaoTurmaDisciplina.NewRow();
                            dtAlunoAvaliacaoTurmaDisciplina.Rows.Add(
                                CLS_AlunoAvaliacaoTurmaDisciplinaBO.EntityToDataRow(alunoAvaliacaoTurmaDisciplina, drAlunoAvaliacaoTurmaDisciplina));
                        }
                    }
                    );
                }

                if (dtAlunoAvaliacaoTurmaDisciplina.Rows.Count > 0)
                {
                    CLS_AlunoAvaliacaoTurmaDisciplinaBO.SalvarEmLotePosConselho(dtAlunoAvaliacaoTurmaDisciplina, banco);

                    if (entFormatoAvaliacao.fav_fechamentoAutomatico && listaAlunoAvaliacaoTurmaDisciplina.Any())
                    {
                        FilaProcessamento.AddRange(listaAlunoAvaliacaoTurmaDisciplina
                                                   .Select(p => new AlunoFechamentoPendencia {
                            tud_id         = p.tud_id,
                            tpc_id         = (p.tpc_id > 0 ? p.tpc_id : tpc_idUltimoPeriodo),
                            afp_frequencia = true,
                            afp_nota       = true,
                            afp_processado = (Byte)(p.atd_id <= 0 ? 0 : 2)
                        }).ToList());
                    }
                }


                foreach (ACA_AlunoAnotacao alunoAnotacao in listaAlunoAnotacao)
                {
                    ACA_AlunoAnotacaoBO.Save(alunoAnotacao, banco);
                }

                CLS_AlunoAvaliacaoTurmaDisciplinaBO.SaveAvaliacaoFinal(
                    tur_id
                    , entFormatoAvaliacao
                    , listaDisciplina
                    , tamanhoMaximoKB
                    , TiposArquivosPermitidos
                    , dataUltimaAlteracaoNotaFinal
                    , listaMatriculaTurmaDisciplina
                    , ref listaAtualizacaoEfetivacao
                    , banco);

                if (entFormatoAvaliacao.fav_fechamentoAutomatico && listaMatriculaTurmaDisciplina.Any() && (tpc_idUltimoPeriodo > 0))
                {
                    FilaProcessamento.AddRange(listaMatriculaTurmaDisciplina
                                               .Select(p => new AlunoFechamentoPendencia {
                        tud_id         = p.tud_id,
                        tpc_id         = tpc_idUltimoPeriodo,
                        afp_frequencia = true,
                        afp_nota       = true,
                        afp_processado = (Byte)(p.mtd_id <= 0 ? 0 : 2)
                    }).ToList());
                }

                if (permiteEditarResultadoFinal)
                {
                    // Se for passado o resultado, salva na MTR_MatriculaTurma.
                    MTR_MatriculaTurma entMatr = new MTR_MatriculaTurma
                    {
                        alu_id = alu_id
                        ,
                        mtu_id = mtu_id
                    };
                    MTR_MatriculaTurmaBO.GetEntity(entMatr, banco);

                    // So registra a alteracao do parecer conclusivo (resultado)
                    // se for um registro novo e tem valor selecionado, ou se houve alteracao do valor.
                    if ((entMatr.IsNew && entMatr.mtu_resultado > 0) || entMatr.mtu_resultado != resultado)
                    {
                        // Se o registro foi alterado depois da data da alteração mais recente no momento em que os dados foram carregados,
                        // interrompe o salvamento e alerta o usuário de que é necessário atualizar os dados
                        if (entMatr != null && !entMatr.IsNew && Convert.ToDateTime(entMatr.mtu_dataAlteracao.ToString()) > dataUltimaAlteracaoObservacao)
                        {
                            throw new ValidationException("Existe registro alterado mais recentemente, é necessário atualizar os dados.");
                        }
                        else
                        {
                            entMatr.usu_idResultado = usu_idLogado;
                            entMatr.mtu_resultado   = resultado;
                            MTR_MatriculaTurmaBO.Save(entMatr, banco);

                            if (ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.GERAR_HISTORICO_SALVAR_PARECER_CONCLUSIVO, ent_id))
                            {
                                ACA_AlunoHistoricoBO.GeracaoHistoricoPedagogicoPorAluno(entMatr.alu_id, entMatr.mtu_id, banco);
                            }

                            if (entFormatoAvaliacao.fav_fechamentoAutomatico)
                            {
                                FilaProcessamento.Add(new AlunoFechamentoPendencia {
                                    tud_id         = tud_ids.FirstOrDefault(),
                                    tpc_id         = tpc_idUltimoPeriodo,
                                    afp_frequencia = true,
                                    afp_nota       = true,
                                    afp_processado = (Byte)(entMatr.IsNew == true ? 0 : 2)
                                });
                            }
                        }
                    }
                }

                // Limpa cache do fechamento, para atualizar o check, as notas pos-conselho, o parecer e a sintese final.
                string chave = string.Empty;
                int    tpcId = -1;
                listaDadosPeriodo.ForEach(q =>
                {
                    // Fechamento de bimestre
                    chave = MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Periodo(tur_id, entFormatoAvaliacao.fav_id, q.ava_id);
                    if (HttpContext.Current != null)
                    {
                        HttpContext.Current.Cache.Remove(chave);
                    }
                    chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelect_ComponentesRegencia_By_TurmaFormato(tur_id, entFormatoAvaliacao.fav_id, q.ava_id);
                    CacheManager.Factory.Remove(chave);

                    // Fechamento final
                    chave = MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Final(tur_id, entFormatoAvaliacao.fav_id, q.ava_id);
                    if (HttpContext.Current != null)
                    {
                        HttpContext.Current.Cache.Remove(chave);
                    }
                    chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelect_ComponentesRegencia_By_TurmaFormato_Final(tur_id, entFormatoAvaliacao.fav_id, q.ava_id);
                    CacheManager.Factory.Remove(chave);

                    // Fechamento automatico de bimestre
                    if (dicAvaTpc.TryGetValue(q.ava_id, out tpcId))
                    {
                        chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_COMPONENTES_REGENCIA_MODEL_KEY, tur_id, tpcId);
                        CacheManager.Factory.Remove(chave);
                    }

                    // Fechamento automatico final
                    chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_COMPONENTES_REGENCIA_MODEL_KEY, tur_id);
                    CacheManager.Factory.Remove(chave);
                });
                List <TUR_TurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, null, GestaoEscolarUtilBO.MinutosCacheLongo);
                listaDisciplinas.ForEach(p =>
                {
                    // Fechamento de bimestre
                    chave = String.Format("{0}_{1}_{2}", ModelCache.FECHAMENTO_BIMESTRE_PATTERN_KEY, p.tud_id, entFormatoAvaliacao.fav_id);
                    CacheManager.Factory.RemoveByPattern(chave);
                    chave = String.Format("{0}_{1}_{2}", ModelCache.FECHAMENTO_BIMESTRE_FILTRO_DEFICIENCIA_PATTERN_KEY, p.tud_id, entFormatoAvaliacao.fav_id);
                    CacheManager.Factory.RemoveByPattern(chave);

                    // Fechamento final
                    chave = String.Format("{0}_{1}_{2}", ModelCache.FECHAMENTO_FINAL_PATTERN_KEY, p.tud_id, entFormatoAvaliacao.fav_id);
                    CacheManager.Factory.RemoveByPattern(chave);
                    chave = String.Format("{0}_{1}_{2}", ModelCache.FECHAMENTO_FINAL_FILTRO_DEFICIENCIA_PATTERN_KEY, p.tud_id, entFormatoAvaliacao.fav_id);
                    CacheManager.Factory.RemoveByPattern(chave);

                    // Fechamento automatico final
                    chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_MODEL_KEY, p.tud_id);
                    CacheManager.Factory.Remove(chave);
                    chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id);
                    CacheManager.Factory.Remove(chave);

                    listaDadosPeriodo.ForEach(q =>
                    {
                        // Fechamento automatico de bimestre
                        if (dicAvaTpc.TryGetValue(q.ava_id, out tpcId))
                        {
                            chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_MODEL_KEY, p.tud_id, tpcId);
                            CacheManager.Factory.Remove(chave);
                            chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id, tpcId);
                            CacheManager.Factory.Remove(chave);
                        }
                    });
                });
                //

                //Adiciona tuds para processamento de pendência de notas (quando salva o parecer final
                foreach (long tud in tud_ids.Where(t => !FilaProcessamento.Any(f => f.tud_id == t)))
                {
                    FilaProcessamento.Add(new AlunoFechamentoPendencia
                    {
                        tud_id                = tud,
                        tpc_id                = tpc_idUltimoPeriodo,
                        afp_frequencia        = false,
                        afp_frequenciaExterna = false,
                        afp_nota              = true,
                        afp_processado        = (byte)2
                    });
                }

                if (entFormatoAvaliacao.fav_fechamentoAutomatico && FilaProcessamento.Any(a => a.tpc_id > 0))
                {
                    CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(
                        FilaProcessamento
                        .GroupBy(g => new { g.tud_id, g.tpc_id })
                        .Select(p => new AlunoFechamentoPendencia {
                        tud_id         = p.FirstOrDefault().tud_id,
                        tpc_id         = p.FirstOrDefault().tpc_id,
                        afp_frequencia = p.FirstOrDefault().afp_frequencia,
                        afp_nota       = p.FirstOrDefault().afp_nota,
                        afp_processado = FilaProcessamento
                                         .Where(w => w.tud_id == p.FirstOrDefault().tud_id&& w.tpc_id == p.FirstOrDefault().tpc_id)
                                         .Min(m => m.afp_processado)
                    })
                        .Where(w => w.tpc_id > 0 && w.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
                        .ToList()
                        , banco);
                }

                return(true);
            }
            catch (ValidationException ex)
            {
                banco.Close(ex);
                throw;
            }
            catch (Exception ex)
            {
                banco.Close(ex);
                throw;
            }
            finally
            {
                if (banco.ConnectionIsOpen)
                {
                    banco.Close();
                }
            }
        }
Пример #4
0
        public static bool SalvarFechamentoAutomaticoEmLote(List <CLS_AlunoAvaliacaoTurmaDisciplina> ltAlunoAvaliacaoTurmaDisciplina,
                                                            List <CLS_AlunoFechamento> ltAlunoFechamento,
                                                            List <MTR_MatriculaTurmaDisciplina> ltMatriculaTurmaDisciplinaResultado,
                                                            TalkDBTransaction banco = null)
        {
            CLS_AlunoFechamentoDAO dao = new CLS_AlunoFechamentoDAO();

            if (banco == null)
            {
                dao._Banco.Open(IsolationLevel.ReadCommitted);
            }
            else
            {
                dao._Banco = banco;
            }

            try
            {
                using (DataTable dtAlunoAvaliacaoTurmaDisciplina = CLS_AlunoAvaliacaoTurmaDisciplina.TipoTabela_AlunoAvaliacaoTurmaDisciplina(),
                       dtAlunoFechamento = CLS_AlunoFechamento.TipoTabela_AlunoFechamento(),
                       dtMatriculaTurmaDisciplinaResultado = MTR_MatriculaTurmaDisciplina.TipoTabela_MatriculaTurmaDisciplinaResultado())
                {
                    if (ltAlunoAvaliacaoTurmaDisciplina.Any())
                    {
                        ltAlunoAvaliacaoTurmaDisciplina.ForEach
                        (
                            p =>
                        {
                            DataRow dr = dtAlunoAvaliacaoTurmaDisciplina.NewRow();
                            dtAlunoAvaliacaoTurmaDisciplina.Rows.Add(CLS_AlunoAvaliacaoTurmaDisciplinaBO.EntityToDataRow(p, dr));
                        }
                        );
                    }

                    if (ltAlunoFechamento.Any())
                    {
                        ltAlunoFechamento.ForEach
                        (
                            p =>
                        {
                            DataRow dr = dtAlunoFechamento.NewRow();
                            dtAlunoFechamento.Rows.Add(EntityToDataRow(p, dr));
                        }
                        );
                    }

                    if (ltMatriculaTurmaDisciplinaResultado.Any())
                    {
                        ltMatriculaTurmaDisciplinaResultado.ForEach
                        (
                            p =>
                        {
                            DataRow dr            = dtMatriculaTurmaDisciplinaResultado.NewRow();
                            dr["alu_id"]          = p.alu_id;
                            dr["mtu_id"]          = p.mtu_id;
                            dr["mtd_id"]          = p.mtd_id;
                            dr["mtd_avaliacao"]   = DBNull.Value;
                            dr["mtd_relatorio"]   = DBNull.Value;
                            dr["mtd_frequencia"]  = DBNull.Value;
                            dr["mtd_resultado"]   = p.mtd_resultado;
                            dr["apenasResultado"] = p.apenasResultado;
                            dtMatriculaTurmaDisciplinaResultado.Rows.Add(dr);
                        }
                        );
                    }

                    return(dao.SalvarFechamentoAutomaticoEmLote(dtAlunoAvaliacaoTurmaDisciplina, dtAlunoFechamento, dtMatriculaTurmaDisciplinaResultado));
                }
            }
            catch (Exception ex)
            {
                dao._Banco.Close(ex);
                throw;
            }
            finally
            {
                if (banco == null && dao._Banco.ConnectionIsOpen)
                {
                    dao._Banco.Close();
                }
            }
        }
        /// <summary>
        /// O método salva as observações para conselho pedagógico.
        /// </summary>
        /// <param name="tur_id">ID da turma.</param>
        /// <param name="alu_id">ID do aluno.</param>
        /// <param name="mtu_id">ID da matrícula turma do aluno.</param>
        /// <param name="fav_id">ID do formato de avaliação.</param>
        /// <param name="ava_id">ID da avaliação.</param>
        /// <param name="ltObservacao">Lista de observações.</param>
        /// <param name="banco">Banco</param>
        /// <param name="ent_id">Id da entidade do usuário logado.</param>
        /// <returns></returns>
        public static bool SalvarObservacao
        (
            long tur_id,
            long alu_id,
            int mtu_id,
            int fav_id,
            int ava_id,
            CLS_AlunoAvaliacaoTur_Observacao observacao,
            Guid usu_idLogado,
            byte resultado,
            string justificativaResultado,
            DateTime dataUltimaAlteracaoObservacao,
            DateTime dataUltimaAlteracaoNotaFinal,
            ACA_FormatoAvaliacao entFormatoAvaliacao,
            List <CLS_AvaliacaoTurDisc_Cadastro> listaDisciplina,
            List <MTR_MatriculaTurmaDisciplina> listaMatriculaTurmaDisciplina,
            int tamanhoMaximoKB,
            string[] TiposArquivosPermitidos,
            ref List <CLS_AlunoAvaliacaoTurmaDisciplina> listaAtualizacaoEfetivacao,
            Guid ent_id,
            int tpc_id
        )
        {
            TalkDBTransaction banco = new CLS_AlunoAvaliacaoTurmaObservacaoDAO()._Banco.CopyThisInstance();

            banco.Open(IsolationLevel.ReadCommitted);

            List <AlunoFechamentoPendencia> FilaProcessamento = new List <AlunoFechamentoPendencia>();

            try
            {
                if (observacao.entityObservacao != null && observacao.entityObservacao != new CLS_AlunoAvaliacaoTurmaObservacao())
                {
                    Save(observacao.entityObservacao, banco);
                }
                int tpc_idUtilizado = -1;

                List <CLS_AvaliacaoTurDisc_Cadastro> listaDisciplinasUltimoPeriodo = new List <CLS_AvaliacaoTurDisc_Cadastro>();
                listaDisciplinasUltimoPeriodo = listaDisciplina.Where(d => d.entity.ava_id != ava_id).ToList();
                if (listaDisciplinasUltimoPeriodo.Count > 0)
                {
                    tpc_idUtilizado = ACA_AvaliacaoBO.SelecionaMaiorBimestre_ByFormatoAvaliacao(entFormatoAvaliacao.fav_id, banco);
                }

                CLS_AlunoAvaliacaoTurmaDisciplinaBO.SaveAvaliacaoFinal(
                    tur_id
                    , entFormatoAvaliacao
                    , listaDisciplina
                    , tamanhoMaximoKB
                    , TiposArquivosPermitidos
                    , dataUltimaAlteracaoNotaFinal
                    , listaMatriculaTurmaDisciplina
                    , ref listaAtualizacaoEfetivacao
                    , banco);

                tpc_idUtilizado = tpc_idUtilizado > 0 ? tpc_idUtilizado : tpc_id;
                if (entFormatoAvaliacao.fav_fechamentoAutomatico && listaMatriculaTurmaDisciplina.Any())
                {
                    FilaProcessamento.AddRange(listaMatriculaTurmaDisciplina
                                               .Select(p => new AlunoFechamentoPendencia {
                        tud_id         = p.tud_id,
                        tpc_id         = tpc_idUtilizado,
                        afp_frequencia = true,
                        afp_nota       = true,
                        afp_processado = (Byte)(p.mtd_id <= 0 ? 0 : 2)
                    }).ToList());
                }

                // Se for passado o resultado, salva na MTR_MatriculaTurma.
                if (!usu_idLogado.Equals(Guid.Empty))
                {
                    MTR_MatriculaTurma entMatr = new MTR_MatriculaTurma
                    {
                        alu_id = alu_id
                        ,
                        mtu_id = mtu_id
                    };
                    MTR_MatriculaTurmaBO.GetEntity(entMatr, banco);

                    // Se o registro foi alterado depois da data da alteração mais recente no momento em que os dados foram carregados,
                    // interrompe o salvamento e alerta o usuário de que é necessário atualizar os dados
                    if (entMatr != null && !entMatr.IsNew && Convert.ToDateTime(entMatr.mtu_dataAlteracao.ToString()) > dataUltimaAlteracaoObservacao)
                    {
                        throw new ValidationException("Existe registro alterado mais recentemente, é necessário atualizar os dados.");
                    }
                    else
                    {
                        entMatr.usu_idResultado = usu_idLogado;
                        entMatr.mtu_resultado   = resultado;
                        entMatr.mtu_relatorio   = justificativaResultado;
                        MTR_MatriculaTurmaBO.Save(entMatr, banco);

                        if (ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.GERAR_HISTORICO_SALVAR_PARECER_CONCLUSIVO, ent_id))
                        {
                            ACA_AlunoHistoricoBO.GeracaoHistoricoPedagogicoPorAluno(entMatr.alu_id, entMatr.mtu_id, banco);
                        }

                        if (entFormatoAvaliacao.fav_fechamentoAutomatico)
                        {
                            FilaProcessamento.Add(new AlunoFechamentoPendencia {
                                tud_id         = listaMatriculaTurmaDisciplina.FirstOrDefault().tud_id,
                                tpc_id         = tpc_id,
                                afp_frequencia = true,
                                afp_nota       = true,
                                afp_processado = (Byte)(entMatr.IsNew == true ? 0 : 2)
                            });
                        }
                    }
                }

                // Limpa cache do fechamento, para atualizar o check.
                GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Periodo(tur_id, fav_id, ava_id));
                List <TUR_TurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, null, GestaoEscolarUtilBO.MinutosCacheLongo);
                listaDisciplinas.ForEach(p =>
                {
                    GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodo(p.tud_id, fav_id, ava_id, string.Empty));
                    GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodoFiltroDeficiencia(p.tud_id, fav_id, ava_id, string.Empty));

                    // Chaves do fechamento automatico
                    string chave = string.Empty;
                    chave        = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_MODEL_KEY, p.tud_id, tpc_id);
                    CacheManager.Factory.RemoveByPattern(chave);

                    chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id, tpc_id);
                    CacheManager.Factory.RemoveByPattern(chave);

                    chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_MODEL_KEY, p.tud_id);
                    CacheManager.Factory.RemoveByPattern(chave);

                    chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id);
                    CacheManager.Factory.RemoveByPattern(chave);

                    chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_COMPONENTES_REGENCIA_MODEL_KEY, tur_id, tpc_id);
                    CacheManager.Factory.RemoveByPattern(chave);

                    chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_COMPONENTES_REGENCIA_MODEL_KEY, tur_id, tpc_id);
                    CacheManager.Factory.RemoveByPattern(chave);
                    //
                });

                if (entFormatoAvaliacao.fav_fechamentoAutomatico && FilaProcessamento.Any(a => a.tpc_id > 0))
                {
                    CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(
                        FilaProcessamento
                        .GroupBy(g => new { g.tud_id, g.tpc_id })
                        .Select(p => new AlunoFechamentoPendencia {
                        tud_id         = p.FirstOrDefault().tud_id,
                        tpc_id         = p.FirstOrDefault().tpc_id,
                        afp_frequencia = p.FirstOrDefault().afp_frequencia,
                        afp_nota       = p.FirstOrDefault().afp_nota,
                        afp_processado = FilaProcessamento
                                         .Where(w => w.tud_id == p.FirstOrDefault().tud_id&& w.tpc_id == p.FirstOrDefault().tpc_id)
                                         .Min(m => m.afp_processado)
                    })
                        .Where(w => w.tpc_id > 0 && w.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
                        .ToList()
                        , banco);
                }

                return(true);
            }
            catch (ValidationException ex)
            {
                banco.Close(ex);
                throw;
            }
            catch (Exception ex)
            {
                banco.Close(ex);
                throw;
            }
            finally
            {
                if (banco.ConnectionIsOpen)
                {
                    banco.Close();
                }
            }
        }