Beispiel #1
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);
        }
Beispiel #2
0
        public static bool Save
        (
            CLS_TurmaNota entity,
            TUR_Turma entTurma,
            DateTime cal_dataInicio,
            DateTime cal_dataFim,
            DateTime cap_dataInicio,
            DateTime cap_dataFim,
            Guid ent_id,
            List <CLS_TurmaNotaOrientacaoCurricular> lstHabilidades,
            bool fav_permiteRecuperacaoForaPeriodo,
            CLS_TurmaAula entityTurmaAula = null,
            CLS_TurmaNotaRegencia entityTurmaNotaRegencia = null,
            bool validarDataAula = true,
            Guid usu_id          = new Guid(),
            byte origemLogNota   = 0,
            byte tipoLogNota     = 0
        )
        {
            TalkDBTransaction banco = new CLS_TurmaNotaDAO()._Banco.CopyThisInstance();

            banco.Open(IsolationLevel.ReadCommitted);

            try
            {
                bool bRetorno = false;

                // Caso tenha selecionado uma aula para vincular à atividade.
                if (validarDataAula && entity.tnt_data == new DateTime())
                {
                    CLS_TurmaAula entityAula = new CLS_TurmaAula
                    {
                        tud_id = entity.tud_id,
                        tau_id = entity.tau_id
                    };
                    CLS_TurmaAulaBO.GetEntity(entityAula, banco);

                    // Verifica se o usuário logado tem uma posição compatível à da aula.
                    if ((entity.tdt_posicao > 0) && (entity.tdt_posicao != entityAula.tdt_posicao))
                    {
                        throw new ValidationException("Você não tem permissão para vincular a nova atividade à esta data da aula.");
                    }

                    // Caso o usuário logado tenha selecionado uma aula para vincular e
                    // não seja um docente, copia a posição da aula.
                    entity.tdt_posicao = entityAula.tdt_posicao;
                    entity.usu_id      = entityAula.usu_id;
                }

                // Caso o usuário logado não seja um docente, grava como posição 1.
                if (entity.tdt_posicao < 1)
                {
                    entity.tdt_posicao = 1;
                }

                if (entity.Validate())
                {
                    // Verifica se a atividade foi alterada/excluída por outra pessoa enquanto o usuário tentava alterar a mesma.
                    CLS_TurmaNota entityAtividadeAuxiliar = new CLS_TurmaNota
                    {
                        tud_id = entity.tud_id,
                        tnt_id = entity.tnt_id
                    };
                    GetEntity(entityAtividadeAuxiliar, banco);

                    if (!entityAtividadeAuxiliar.IsNew)
                    {
                        entity.tdt_posicao = entityAtividadeAuxiliar.tdt_posicao;
                        entity.usu_id      = entityAtividadeAuxiliar.usu_id;
                    }

                    if (entityAtividadeAuxiliar.tnt_dataAlteracao != entity.tnt_dataAlteracao)
                    {
                        throw new EditarAtividade_ValidationException("Esta atividade já foi alterada recentemente.");
                    }

                    string nomeAtividade = GestaoEscolarUtilBO.nomePadraoAtividadeAvaliativa(ent_id);

                    if (entity.tav_id <= 0 && string.IsNullOrEmpty(entity.tnt_nome) && ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.NOME_TODAS_ATIVIDADES_AVALIATIVAS, ent_id) == "False")
                    {
                        throw new ArgumentException(string.Format("Outro tipo de {0} é obrigatório.", nomeAtividade.ToLower()));
                    }

                    CLS_TipoAtividadeAvaliativa entityAtividade = new CLS_TipoAtividadeAvaliativa();
                    if (entity.tav_id <= 0)
                    {
                        if (entity.tnt_nome.Length > 100)
                        {
                            throw new ArgumentException(nomeAtividade + " pode conter até 100 caracteres.");
                        }
                    }
                    else
                    {
                        entityAtividade.tav_id = entity.tav_id;
                        CLS_TipoAtividadeAvaliativaBO.GetEntity(entityAtividade, banco);
                    }

                    if (entity.tnt_situacao != Convert.ToByte(CLS_TurmaNotaSituacao.AtividadeCancelada) || (entityAtividadeAuxiliar.tnt_situacao == entity.tnt_situacao))
                    {
                        if ((entityAtividade.tav_situacao == Convert.ToByte(CLS_TipoAtividadeAvaliativaSituacao.Inativo)) && (entityAtividade.tav_id != entityAtividadeAuxiliar.tav_id))
                        {
                            throw new ArgumentException(string.Format("Tipo de {0} está inativo.", nomeAtividade.ToLower()));
                        }
                    }

                    CLS_TurmaNota avaRecuperacao = CLS_TurmaNotaBO.GetSelectRelacionadaFilho(entity.tud_id, entity.tnt_id, banco);
                    if (entity.tnt_data != new DateTime())
                    {
                        if (entTurma.tur_id <= 0)
                        {
                            entTurma = new TUR_Turma {
                                tur_id = entity.tur_id
                            };
                            TUR_TurmaBO.GetEntity(entTurma, banco);
                        }

                        // Compara as datas das avaliacoes relacionadas
                        bool          relacionadaPai = false;
                        CLS_TurmaNota avaRelacionada = CLS_TurmaNotaBO.GetSelectRelacionadaFilho(entity.tud_id, entity.tnt_id, banco);
                        if (avaRelacionada.tnt_id > 0)
                        {
                            // se a data da recuperacao filho eh menor que a data da avaliacao pai...
                            if (avaRecuperacao.tnt_data != new DateTime() && avaRecuperacao.tnt_data < entity.tnt_data)
                            {
                                throw new ArgumentException(CustomResource.GetGlobalResourceObject("Academico", "LancamentoAvaliacao.UCCadastroAvaliacao.lblMessageAtividade.ValidacaoDataFilho").ToString());
                            }
                        }
                        else
                        {
                            avaRelacionada = CLS_TurmaNotaBO.GetSelectRelacionadaPai(entity.tud_id, entity.tnt_id);
                            relacionadaPai = avaRelacionada.tnt_id > 0;
                            avaRelacionada = CLS_TurmaNotaBO.GetSelectRelacionadaPai(entity.tud_id, entity.tnt_id, banco);
                            // se a data da avaliacao pai eh maior que a data da recuperacao filho...
                            if (avaRelacionada.tnt_id > 0 && avaRelacionada.tnt_data != new DateTime() && avaRelacionada.tnt_data > entity.tnt_data)
                            {
                                throw new ArgumentException(CustomResource.GetGlobalResourceObject("Academico", "LancamentoAvaliacao.UCCadastroAvaliacao.lblMessageAtividade.ValidacaoDataPai").ToString());
                            }
                        }

                        if (!(fav_permiteRecuperacaoForaPeriodo && relacionadaPai) &&
                            (entity.tnt_data > cal_dataFim || entity.tnt_data < cal_dataInicio))
                        {
                            throw new ArgumentException("A data da atividade deve estar dentro do período do calendário escolar (" + cal_dataInicio.ToString("dd/MM/yyyy") + " - " + cal_dataFim.ToString("dd/MM/yyyy") + ").");
                        }

                        if (!(fav_permiteRecuperacaoForaPeriodo && relacionadaPai) &&
                            (entity.tnt_data > cap_dataFim || entity.tnt_data < cap_dataInicio))
                        {
                            throw new ArgumentException("A data da atividade deve estar dentro do período do calendário (" + cap_dataInicio.ToString("dd/MM/yyyy") + " - " + cap_dataFim.ToString("dd/MM/yyyy") + ").");
                        }
                    }

                    // Valida se existe aluno com habilidade nao selecionada na avaliacao
                    if (entity.tnt_id > 0 && !CLS_TurmaNotaAlunoOrientacaoCurricularBO.ValidarHabilidadesAvaliacao(lstHabilidades, banco))
                    {
                        throw new ArgumentException(CustomResource.GetGlobalResourceObject("Academico", "LancamentoAvaliacao.UCCadastroAvaliacao.lblMessageAtividade.ValidaHabilidadesAluno").ToString());
                    }

                    // Valida se existe aluno na avaliacao de recuperacao, com habilidade
                    // que nao esta mais selecionada na avaliacao normal
                    if (avaRecuperacao.tnt_id > 0 && !CLS_TurmaNotaAlunoOrientacaoCurricularBO.ValidarHabilidadesAvaliacao(lstHabilidades, banco, avaRecuperacao.tnt_id))
                    {
                        throw new ArgumentException(CustomResource.GetGlobalResourceObject("Academico", "LancamentoAvaliacao.UCCadastroAvaliacao.lblMessageAtividade.ValidaHabilidadesAlunoRecuperacao").ToString());
                    }

                    CLS_ConfiguracaoAtividadeQualificador configQualificador = new CLS_ConfiguracaoAtividadeQualificador();
                    CLS_TurmaNotaDAO dao = new CLS_TurmaNotaDAO {
                        _Banco = banco
                    };
                    if (entity.IsNew && entity.tav_id > 0 && entityAtividade.qat_id > 0)
                    {
                        CLS_ConfiguracaoAtividadeQualificadorDAO configQualificadorDao = new CLS_ConfiguracaoAtividadeQualificadorDAO();
                        configQualificadorDao._Banco = banco;
                        configQualificador           = configQualificadorDao.GetSelectByTudQualificador(entity.tud_id, entityAtividade.qat_id);

                        // Valida a quantidade configurada para o qualificador
                        if (configQualificador.caa_id > 0 && configQualificador.caq_quantidade >= 0)
                        {
                            if (dao.ValidaQuantidadeMaxima(entity.tud_id, entityAtividade.qat_id, entity.tpc_id, configQualificador.caq_quantidade))
                            {
                                throw new ArgumentException(CustomResource.GetGlobalResourceObject("Academico", "LancamentoAvaliacao.UCCadastroAvaliacao.lblMessageAtividade.ValidacaoQuantidade").ToString());
                            }
                        }
                    }

                    bRetorno = dao.Salvar(entity);

                    if (entity.IsNew &&
                        configQualificador.caa_id > 0 &&
                        configQualificador.caq_possuiRecuperacao)
                    {
                        int tavIdRelacionado = CLS_TipoAtividadeAvaliativaBO.SelecionaTipoAtividadeAvaliativaRelacionado(configQualificador.caa_id, configQualificador.qat_id, banco);
                        if (tavIdRelacionado > 0)
                        {
                            CLS_TurmaNota entityRelacionada = new CLS_TurmaNota();
                            entityRelacionada.tud_id                 = entity.tud_id;
                            entityRelacionada.IsNew                  = true;
                            entityRelacionada.tpc_id                 = entity.tpc_id;
                            entityRelacionada.tnt_situacao           = 1;
                            entityRelacionada.tav_id                 = tavIdRelacionado;
                            entityRelacionada.tdt_posicao            = entity.tdt_posicao;
                            entityRelacionada.tnt_exclusiva          = false;
                            entityRelacionada.usu_id                 = entity.usu_id;
                            entityRelacionada.usu_idDocenteAlteracao = entity.usu_idDocenteAlteracao;
                            dao.Salvar(entityRelacionada);

                            CLS_TurmaNotaRelacionada entityRelacionamento = new CLS_TurmaNotaRelacionada();
                            entityRelacionamento.IsNew             = true;
                            entityRelacionamento.tud_id            = entity.tud_id;
                            entityRelacionamento.tnt_id            = entity.tnt_id;
                            entityRelacionamento.tud_idRelacionada = entityRelacionada.tud_id;
                            entityRelacionamento.tnt_idRelacionada = entityRelacionada.tnt_id;
                            CLS_TurmaNotaRelacionadaBO.Save(entityRelacionamento, banco);

                            avaRecuperacao = entityRelacionada;
                        }
                    }

                    #region Salva as Orientacoes curriculares ligadas a avaliacao

                    if (bRetorno && lstHabilidades.Any())
                    {
                        lstHabilidades.ForEach(x => x.tnt_id = entity.tnt_id);
                        bRetorno = CLS_TurmaNotaOrientacaoCurricularBO.SalvarEmLote(lstHabilidades, banco);

                        // Copia as habilidades na avaliacao de recuperacao
                        if (avaRecuperacao.tnt_id > 0)
                        {
                            // Salva as Orientacoes curriculares ligadas a avaliacao - específico para recuperação.
                            lstHabilidades.ForEach(x => x.tnt_id = avaRecuperacao.tnt_id);
                            CLS_TurmaNotaOrientacaoCurricularBO.SalvarEmLote(lstHabilidades, banco);
                        }
                    }

                    #endregion Salva as Orientacoes curriculares ligadas a avaliacao

                    #region Salva a turma Aula

                    if (entityTurmaAula != null)
                    {
                        bRetorno = CLS_TurmaAulaBO.Save(entityTurmaAula, banco);
                    }

                    #endregion Salva a turma Aula

                    // Salva o vinculo com a aula, caso seja regência
                    if (entityTurmaNotaRegencia != null)
                    {
                        entityTurmaNotaRegencia.tnt_id = entity.tnt_id;
                        bRetorno = CLS_TurmaNotaRegenciaBO.Save(entityTurmaNotaRegencia, banco);
                    }

                    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, banco);
                    }

                    return(bRetorno);
                }

                throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity));
            }
            catch (Exception err)
            {
                banco.Close(err);
                throw;
            }
            finally
            {
                banco.Close();
            }
        }