Exemplo n.º 1
0
        /// <summary>
        /// Salva anotações e recursos para os alunos.
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="listTurmaAulaRecursoRegencia"></param>
        /// <param name="banco"></param>
        /// <param name="ent_id">Id da entidade do usuário logado.</param>
        /// <param name="turmaIntegral">Indica se a turma é integral.</param>
        /// <param name="fechamentoAutomatico">Indica se o fechamento é automático.</param>
        /// <param name="salvarFaltasAlunos"></param>
        /// <returns></returns>
        private static bool SalvarAulaAnotacoesRecursos
        (
            CLS_TurmaAulaRegencia entity
            , List <CLS_TurmaAulaRecursoRegencia> listTurmaAulaRecursoRegencia
            , TalkDBTransaction banco
            , Guid ent_id
            , bool turmaIntegral
            , bool fechamentoAutomatico
            , List <VigenciaCriacaoAulas> vigenciasCriacaoAulas
            , bool salvarFaltasAlunos = false
            , List <CLS_TurmaAulaOrientacaoCurricular> listOriCurTurAula = null
            , Guid usu_id        = new Guid()
            , byte origemLogAula = 0
            , byte tipoLogAula   = 0
        )
        {
            string mensagemInfo;

            if (entity.tuf_data == new DateTime())
            {
                throw new ValidationException("Data da aula é obrigatório.");
            }

            // Chama método padrão para salvar a aula
            if (entity.Validate())
            {
                Save(entity, banco);
            }
            else
            {
                throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
            }

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

                LOG_TurmaAula_AlteracaoBO.Save(entLogAula, banco);
            }

            // regravo a CLS_TurmaAula apenas para atualizar o campo usu_idDocenteAlteracao, quando preenchido
            if (entity.usu_idDocenteAlteracao != null)
            {
                CLS_TurmaAula entityAula = new CLS_TurmaAula
                {
                    tud_id = entity.tud_id
                    ,
                    tau_id = entity.tau_id
                };
                CLS_TurmaAulaBO.GetEntity(entityAula);

                if (!entityAula.IsNew)
                {
                    entityAula.usu_idDocenteAlteracao = entity.usu_idDocenteAlteracao;
                    CLS_TurmaAulaBO.Save(entityAula, banco, out mensagemInfo, ent_id, turmaIntegral, fechamentoAutomatico, vigenciasCriacaoAulas);
                }
            }

            //Carrega Recursos gravados no banco
            List <CLS_TurmaAulaRecursoRegencia> listaBanco = CLS_TurmaAulaRecursoRegenciaBO.GetSelectBy_Turma_Aula_DisciplinaComponente(entity.tud_id
                                                                                                                                        , entity.tau_id
                                                                                                                                        , entity.tud_idFilho);
            //busca registros que devem ser excluidos
            IEnumerable <Int32> dadosTela =
                (from CLS_TurmaAulaRecursoRegencia dr in listTurmaAulaRecursoRegencia.AsEnumerable()
                 orderby dr.rsa_id descending
                 select dr.rsa_id).AsEnumerable();

            IEnumerable <Int32> dadosExcluir =
                (from CLS_TurmaAulaRecursoRegencia t in listaBanco.AsEnumerable()
                 orderby t.rsa_id descending
                 select t.rsa_id).Except(dadosTela);

            IList <Int32> dadosDif = dadosExcluir.ToList();

            //deleta registros que foram desmarcados
            for (int i = 0; i < dadosDif.Count; i++)
            {
                CLS_TurmaAulaRecursoRegenciaBO.Delete_Byrsa_id(entity.tud_id, entity.tau_id, dadosDif[i]);
            }

            //busca registro que devem ser alterados
            IEnumerable <Int32> dadosBanco =
                (from CLS_TurmaAulaRecursoRegencia t in listaBanco.AsEnumerable()
                 orderby t.rsa_id descending
                 select t.rsa_id).AsEnumerable();

            IEnumerable <Int32> dadosAlterar =
                (from CLS_TurmaAulaRecursoRegencia t in listTurmaAulaRecursoRegencia.AsEnumerable()
                 orderby t.rsa_id descending
                 select t.rsa_id).Intersect(dadosBanco);

            IList <Int32> dadosAlte = dadosAlterar.ToList();
            CLS_TurmaAulaRecursoRegencia entityAltera;

            for (int i = 0; i < dadosAlte.Count; i++)
            {
                entityAltera = listTurmaAulaRecursoRegencia.Find(p => p.rsa_id == dadosAlte[i]);
                entityAltera.trr_dataAlteracao = DateTime.Now;
                CLS_TurmaAulaRecursoRegenciaBO.Update_Byrsa_id(entityAltera);
                listTurmaAulaRecursoRegencia.Remove(entityAltera);
            }

            // Salva as recursos utilizados na aula
            foreach (CLS_TurmaAulaRecursoRegencia aux in listTurmaAulaRecursoRegencia)
            {
                aux.tau_id = entity.tau_id;
                if (aux.Validate())
                {
                    CLS_TurmaAulaRecursoRegenciaBO.Salvar(aux, banco);
                }
                else
                {
                    throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(aux));
                }
            }

            return(true);
        }
Exemplo n.º 2
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);
        }