Ejemplo n.º 1
0
        public new static bool Delete
        (
            CLS_TurmaNota entity,
            Guid usu_id        = new Guid(),
            byte origemLogNota = 0,
            byte tipoLogNota   = 0
        )
        {
            CLS_TurmaNotaDAO dao = new CLS_TurmaNotaDAO();

            dao._Banco.Open(IsolationLevel.ReadCommitted);

            try
            {
                //Verifica se for a última atividade e algum aluno da turma possuir nota/parecer final então não permite excluir.
                if (!SelecionaPorTurmaDisciplinaPeriodoCalendario(entity.tud_id, entity.tpc_id, 0, Guid.Empty, dao._Banco).AsEnumerable()
                    .Any(p => Convert.ToInt32(p["tnt_id"]) != entity.tnt_id) &&
                    CLS_AlunoAvaliacaoTurmaDisciplinaMediaBO.BuscaNotasFinaisTud(entity.tud_id, entity.tpc_id, dao._Banco).Any())
                {
                    throw new ValidationException(CustomResource.GetGlobalResourceObject("BLL", "CLS_TurmaNota.ValidacaoExclusaoUltimaAvaliacao").ToString());
                }

                //Deleta logicamente a atividade
                dao.Delete(entity);

                if (origemLogNota > 0 && tipoLogNota > 0)
                {
                    DateTime dataLogNota = DateTime.Now;
                    LOG_TurmaNota_Alteracao entLogNota = new LOG_TurmaNota_Alteracao
                    {
                        tud_id     = entity.tud_id,
                        tnt_id     = entity.tnt_id,
                        usu_id     = usu_id,
                        ltn_origem = origemLogNota,
                        ltn_tipo   = tipoLogNota,
                        ltn_data   = dataLogNota
                    };

                    LOG_TurmaNota_AlteracaoBO.Save(entLogNota, dao._Banco);
                }

                return(true);
            }
            catch (Exception err)
            {
                dao._Banco.Close(err);
                throw;
            }
            finally
            {
                dao._Banco.Close();
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Salva as notas das atividades dos alunos e a propriedade "tnt_efetivado" das
        /// atividades.
        /// <param name="fechamentoAutomatico">Indica se o fechamento é automático.</param>
        /// <param name="origemLogMedia">Se enviar a origem do log então será salvo o LOG_AvaliacaoMedia_Alteracao</param>
        /// <param name="origemLogNota">Se enviar a origem do log então será salvo o LOG_TurmaNota_Alteracao</param>
        /// </summary>
        internal static bool Save
        (
            List <CLS_TurmaNotaAluno> listTurmaNotaAluno
            , List <CLS_TurmaNota> listTurmaNota
            , List <CLS_AlunoAvaliacaoTurmaDisciplinaMedia> listAlunoAvaliacaoTurmaDisciplinaMedia
            , long tur_id
            , long tud_id
            , int tpc_id
            , int fav_id
            , int tdt_posicao
            , TalkDBTransaction banco
            , Guid ent_id
            , bool fechamentoAutomatico
            , Guid usu_id         = new Guid()
            , byte origemLogMedia = 0
            , byte origemLogNota  = 0
            , byte tipoLogNota    = 0
            , long tud_idRegencia = -1
        )
        {
            string errorMSG = string.Empty;

            if (!ValidaParticipantesAvaliacao(listTurmaNota, listTurmaNotaAluno, out errorMSG, ent_id))
            {
                throw new ValidationException(errorMSG);
            }

            object lockObject = new object();

            // Salva os dados de todos os alunos na tabela CLS_TurmaNotaAluno.
            DataTable dtTurmaNotaAluno = CLS_TurmaNotaAluno.TipoTabela_TurmaNotaAluno();

            if (listTurmaNotaAluno.Any())
            {
                Parallel.ForEach
                (
                    listTurmaNotaAluno,
                    turmaNotaAluno =>
                {
                    lock (lockObject)
                    {
                        DataRow dr = dtTurmaNotaAluno.NewRow();
                        dtTurmaNotaAluno.Rows.Add(TurmaNotaAlunoToDataRow(turmaNotaAluno, dr));
                    }
                }
                );
            }
            SalvaNotaAlunos(dtTurmaNotaAluno, banco);

            GestaoEscolarUtilBO.LimpaCache(String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_COMPONENTES_REGENCIA_MODEL_KEY, tur_id, tpc_id));
            GestaoEscolarUtilBO.LimpaCache(ModelCache.FECHAMENTO_BIMESTRE_COMPONENTES_REGENCIA_PATTERN_KEY, tur_id.ToString());

            string tnt_ids = string.Join(",", (from CLS_TurmaNota item in listTurmaNota select item.tnt_id.ToString()).ToArray());
            List <CLS_TurmaNota>           listaTurmaNota;
            List <LOG_TurmaNota_Alteracao> listLogNota = new List <LOG_TurmaNota_Alteracao>();
            // Recupera a lista de entidades CLS_TurmaNotaAluno para verificar se ela já existe.
            CLS_TurmaNotaAlunoDAO tnaDao = new CLS_TurmaNotaAlunoDAO {
                _Banco = banco
            };

            tnaDao.SelectBy_Disciplina_Atividades(tud_id, tnt_ids, out listaTurmaNota);

            DateTime dataLogNota = DateTime.Now;

            foreach (CLS_TurmaNota entTurNota in listTurmaNota)
            {
                // Busca registro - deve existir.
                CLS_TurmaNota entAux = listaTurmaNota.Find
                                           (p => p.tud_id == entTurNota.tud_id &&
                                           p.tnt_id == entTurNota.tnt_id);

                if (entAux != null)
                {
                    // Só altera o tnt_efetivado.
                    entAux.tnt_efetivado          = entTurNota.tnt_efetivado;
                    entAux.usu_idDocenteAlteracao = entTurNota.usu_idDocenteAlteracao;

                    if (!entAux.Validate())
                    {
                        throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entAux));
                    }

                    if ((tdt_posicao <= 0) || (tdt_posicao == entTurNota.tdt_posicao))
                    {
                        CLS_TurmaNotaBO.Save(entAux, banco);

                        if (origemLogNota > 0)
                        {
                            LOG_TurmaNota_Alteracao entLogNota = new LOG_TurmaNota_Alteracao
                            {
                                tud_id     = entAux.tud_id,
                                tnt_id     = entAux.tnt_id,
                                usu_id     = usu_id,
                                ltn_origem = origemLogNota,
                                ltn_tipo   = tipoLogNota,
                                ltn_data   = dataLogNota
                            };

                            listLogNota.Add(entLogNota);
                        }
                    }
                }
            }

            //Salva os logs de alteração de nota
            LOG_TurmaNota_AlteracaoBO.SalvarEmLote(listLogNota, banco);

            // Salva os dados da média.
            if (listAlunoAvaliacaoTurmaDisciplinaMedia != null)
            {
                List <CLS_AlunoAvaliacaoTurmaDisciplinaMedia> listaMediasBimestreBD = CLS_AlunoAvaliacaoTurmaDisciplinaMediaBO.BuscaNotasFinaisTurma(tud_id, tpc_id, banco);
                bool alteracaoMedia = listAlunoAvaliacaoTurmaDisciplinaMedia.Exists(media =>
                                                                                    listaMediasBimestreBD.Any() ?
                                                                                    !listaMediasBimestreBD.Any
                                                                                    (
                                                                                        p => p.tud_id == media.tud_id &&
                                                                                        p.alu_id == media.alu_id &&
                                                                                        p.mtu_id == media.mtu_id &&
                                                                                        p.mtd_id == media.mtd_id &&
                                                                                        (string.IsNullOrEmpty(p.atm_media) ? "" : p.atm_media) == (string.IsNullOrEmpty(media.atm_media) ? "" : media.atm_media)
                                                                                    ) :
                                                                                    !string.IsNullOrEmpty(media.atm_media));

                CLS_AlunoAvaliacaoTurmaDisciplinaMediaBO.SalvarEmLote(tur_id, tud_id, tpc_id, fav_id, listAlunoAvaliacaoTurmaDisciplinaMedia, banco);

                // Salva na fila de processamento e o log caso exista alguma alteração.
                if (alteracaoMedia && listAlunoAvaliacaoTurmaDisciplinaMedia.Count > 0)
                {
                    // Caso o fechamento seja automático, grava na fila de processamento.
                    if (fechamentoAutomatico && tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id))
                    {
                        CLS_AlunoFechamentoPendenciaBO.SalvarFilaNota(tud_id, tpc_id, banco);
                        if (tud_idRegencia > 0)
                        {
                            CLS_AlunoFechamentoPendenciaBO.SalvarFilaNota(tud_idRegencia, tpc_id, banco);
                        }
                    }

                    if (origemLogMedia > 0)
                    {
                        LOG_AvaliacaoMedia_Alteracao log = new LOG_AvaliacaoMedia_Alteracao
                        {
                            tud_id     = tud_id,
                            tpc_id     = tpc_id,
                            usu_id     = usu_id,
                            lam_data   = DateTime.Now,
                            lam_tipo   = (byte)LOG_AvaliacaoMedia_Alteracao_Tipo.AlteracaoMedia,
                            lam_origem = origemLogMedia
                        };
                        LOG_AvaliacaoMedia_AlteracaoBO.Save(log, banco);
                    }
                }
            }

            return(true);
        }