示例#1
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);
        }
示例#2
0
        /// <summary>
        /// Salva os dados da média dos alunos.
        /// </summary>
        /// <param name="ltAlunoAvaliacaoTurmaDisciplinaMedia">Lista de médias dos alunos.</param>
        /// <param name="banco">Transação.</param>
        /// <returns>True em caso de sucesso.</returns>
        public static bool SalvarEmLote(long tur_id, long tud_id, int tpc_id, int fav_id, List <CLS_AlunoAvaliacaoTurmaDisciplinaMedia> ltAlunoAvaliacaoTurmaDisciplinaMedia, TalkDBTransaction banco)
        {
            DataTable dtAlunoAvaliacaoTurmaDisciplinaMedia = CLS_AlunoAvaliacaoTurmaDisciplinaMedia.TipoTabela_AlunoAvaliacaoTurmaDisciplinaMedia();

            if (ltAlunoAvaliacaoTurmaDisciplinaMedia != null && ltAlunoAvaliacaoTurmaDisciplinaMedia.Any())
            {
                object lockObject = new object();

                Parallel.ForEach
                (
                    ltAlunoAvaliacaoTurmaDisciplinaMedia,
                    alunoAvaliacaoTurmaDisciplinaMedia =>
                {
                    lock (lockObject)
                    {
                        DataRow dr = dtAlunoAvaliacaoTurmaDisciplinaMedia.NewRow();
                        dtAlunoAvaliacaoTurmaDisciplinaMedia.Rows.Add(AlunoAvaliacaoTurmaDisciplinaMediaToDataRow(alunoAvaliacaoTurmaDisciplinaMedia, dr));
                    }
                }
                );

                bool retorno = banco == null ?
                               new CLS_AlunoAvaliacaoTurmaDisciplinaMediaDAO().SalvarEmLote(dtAlunoAvaliacaoTurmaDisciplinaMedia) :
                               new CLS_AlunoAvaliacaoTurmaDisciplinaMediaDAO {
                    _Banco = banco
                }.SalvarEmLote(dtAlunoAvaliacaoTurmaDisciplinaMedia);

                if (retorno && HttpContext.Current != null)
                {
                    // Limpa o cache do fechamento
                    try
                    {
                        string chave = string.Empty;
                        List <ACA_Avaliacao> avaliacao = ACA_AvaliacaoBO.GetSelectBy_FormatoAvaliacaoPeriodo(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, fav_id, ava_id, string.Empty);
                                CacheManager.Factory.RemoveByPattern(chave);

                                chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodoFiltroDeficiencia(tud_id, fav_id, ava_id, string.Empty);
                                CacheManager.Factory.RemoveByPattern(chave);

                                chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelect_ComponentesRegencia_By_TurmaFormato(tur_id, fav_id, ava_id);
                                CacheManager.Factory.Remove(chave);
                            }
                            else
                            {
                                chave = MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Periodo(tur_id, fav_id, ava_id);
                                HttpContext.Current.Cache.Remove(chave);
                            }

                            // Recupero o id da avaliacao final para limpar o cache
                            DataTable avaFinal = ACA_AvaliacaoBO.GetSelectBy_TipoAvaliacao(AvaliacaoTipo.Final, fav_id);
                            ava_id = avaFinal.Rows.Count == 0 ? -1 : Convert.ToInt32(avaFinal.Rows[0]["ava_id"]);

                            // Limpa o cache da efetivacao final
                            if (ava_id > 0)
                            {
                                if (tud_id > 0)
                                {
                                    chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaFinal(tud_id, fav_id, ava_id, string.Empty);
                                    CacheManager.Factory.RemoveByPattern(chave);

                                    chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaFinalFiltroDeficiencia(tud_id, fav_id, ava_id, string.Empty);
                                    CacheManager.Factory.RemoveByPattern(chave);

                                    chave = MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelect_ComponentesRegencia_By_TurmaFormato_Final(tur_id, fav_id, ava_id);
                                    CacheManager.Factory.Remove(chave);
                                }
                                else
                                {
                                    chave = MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Final(tur_id, fav_id, ava_id);
                                    HttpContext.Current.Cache.Remove(chave);
                                }
                            }
                        }
                    }
                    catch
                    { }
                }

                return(retorno);
            }

            return(true);
        }
        /// <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();
                }
            }
        }