/// <summary> /// O método salva as observações por disciplina. /// </summary> /// <param name="tud_id">ID da turma disciplina.</param> /// <param name="alu_id">ID do aluno.</param> /// <param name="mtu_id">ID da matrícula turma do aluno.</param> /// <param name="mtd_id">ID da matrícula turma disciplina 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"></param> /// <returns></returns> public static bool SalvarObservacao(long tud_id, long alu_id, int mtu_id, int mtd_id, int fav_id, int ava_id, CLS_AlunoAvaliacaoTurDis_Observacao observacao) { TalkDBTransaction banco = new CLS_AlunoAvaliacaoTurmaDisciplinaObservacaoDAO()._Banco.CopyThisInstance(); banco.Open(IsolationLevel.ReadCommitted); try { if (observacao.entityObservacao != null && observacao.entityObservacao != new CLS_AlunoAvaliacaoTurmaDisciplinaObservacao()) { Save(observacao.entityObservacao, banco); } // Limpa cache do fechamento, para atualizar o check. GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodo(tud_id, fav_id, ava_id, string.Empty)); GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodoFiltroDeficiencia(tud_id, fav_id, ava_id, string.Empty)); return(true); } catch (ValidationException ex) { banco.Close(ex); throw; } catch (Exception ex) { banco.Close(ex); throw; } finally { if (banco.ConnectionIsOpen) { banco.Close(); } } }
private void UCCPeriodoCalendario_IndexChanged() { rptAlunos.DataSource = null; bool possuiAlunos = false; if (UCCPeriodoCalendario.Valor[0] != -1 && UCCPeriodoCalendario.Valor[1] != -1) { long tur_id = Convert.ToInt64(ddlTurma.SelectedValue); TUR_Turma tur = new TUR_Turma(); tur.tur_id = tur_id; TUR_TurmaBO.GetEntity(tur); TUR_TurmaDisciplina tud = new TUR_TurmaDisciplina(); tud.tud_id = UCCTurmaDisciplina1.Valor; TUR_TurmaDisciplinaBO.GetEntity(tud); DateTime cap_dataInicio, cap_dataFim; ACA_CalendarioPeriodoBO.RetornaDatasPeriodoPor_FormatoAvaliacaoTurmaDisciplina(UCCPeriodoCalendario.Valor[0], string.Empty, UCCTurmaDisciplina1.Valor, tur.fav_id, out cap_dataInicio, out cap_dataFim); DataTable dt = _VS_doc_id > 0 && VS_DisciplinaEspecial? MTR_MatriculaTurmaDisciplinaBO.SelecionaAtivosCompensacaoAusenciaFiltroDeficiencia(tur_id, UCCTurmaDisciplina1.Valor, UCCPeriodoCalendario.Valor[0], 0, VS_tipoDocente, VS_cpa_id, false, true) : MTR_MatriculaTurmaDisciplinaBO.SelecionaAtivosCompensacaoAusencia(UCCTurmaDisciplina1.Valor, UCCPeriodoCalendario.Valor[0], 0, VS_cpa_id, false, true); rptAlunos.DataSource = dt; possuiAlunos = dt.Rows.Count > 0; rptAlunos.DataBind(); lblMessage.Text = ""; if (tud.tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia && !TUR_TurmaDisciplinaTerritorioBO.VerificaOferecimentoExperienciaBimestre(UCCTurmaDisciplina1.Valor, UCComboCalendario.Valor, UCCPeriodoCalendario.Valor[0])) { mostraSalvar = false; lblMessage.Text += UtilBO.GetErroMessage("A experiência não possui territórios vigentes no bimestre.", UtilBO.TipoMensagem.Alerta); } if (VS_cpa_id <= 0) { if (possuiAlunos) { btnSalvar.Visible = __SessionWEB.__UsuarioWEB.GrupoPermissao.grp_inserir && mostraSalvar; } else { btnSalvar.Visible = false; lblMessage.Text += UtilBO.GetErroMessage("Não existem alunos com ausências para serem compensadas.", UtilBO.TipoMensagem.Alerta); } } } fdsAlunos.Visible = possuiAlunos; }
/// <summary> /// Carrega dados de lançamento de frequência na tela. /// Só carrega caso a disciplina não seja do tipo /// complementação da regência. /// </summary> public void Carregar(bool proximo , bool anterior , bool inalterado , ControleTurmas entitiesControleTurma , int tpcId , DateTime capDataInicio , DateTime capDataFim , byte tdtPosicao , EnumTipoDocente tipoDocente , long tudIdRelacionada , bool permiteVisualizarCompensacao , List <sPermissaoDocente> ltPermissaoFrequencia , bool permiteLancarFrequencia , out int countAulas , int situacaoTurmaDisciplina , ref bool permiteEdicao , bool usuarioPermissao , bool periodoEfetivado , bool periodoAberto , ref bool esconderSalvar , ref int paginaFreq , int tne_id , string tur_ids = null) { countAulas = 0; long tudId = entitiesControleTurma.turmaDisciplina.tud_id; long turId = entitiesControleTurma.turma.tur_id; int qtdAulasSemana = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.QUANTIDADE_AULAS_LISTAO_FREQUENCIA, __SessionWEB.__UsuarioWEB.Usuario.ent_id); DateTime dtInicio = new DateTime(); DateTime dtFim = new DateTime(); if (proximo) { paginaFreq++; } else if (anterior && paginaFreq > 1) { paginaFreq--; } else if (!inalterado) { paginaFreq = 1; } // Carregar tabela com aulas e frequências das aulas para os alunos. VS_Aulas_Alunos = CLS_TurmaAulaAlunoBO.GetSelectBy_TurmaDisciplina(tudId, tpcId, (__SessionWEB.__UsuarioWEB.Docente.doc_id > 0 ? __SessionWEB.__UsuarioWEB.Usuario.usu_id : Guid.Empty), capDataInicio, capDataFim, tdtPosicao, __SessionWEB.__UsuarioWEB.Docente.doc_id == 0, tudIdRelacionada, tur_ids); int qtdAlunos = VS_Aulas_Alunos.GroupBy(p => new { p.alu_id, p.mtu_id }).Count(); int skip = qtdAulasSemana * (paginaFreq - 1) * qtdAlunos; while (proximo && VS_Aulas_Alunos.Count < skip) { paginaFreq--; skip = (qtdAulasSemana * (paginaFreq - 1)) * qtdAlunos; if (paginaFreq == 1) { break; } } //Quando carrega pela primeira vez e o bimestre é ativo então abre a página que possui a data atual if (!proximo && !anterior && !inalterado && paginaFreq == 1 && capDataInicio <= DateTime.Today && capDataFim >= DateTime.Today) { while (VS_Aulas_Alunos.Skip(skip).Take(qtdAulasSemana * qtdAlunos).ToList().LastOrDefault().tau_data < DateTime.Today && VS_Aulas_Alunos.Skip(skip).Count() > (qtdAulasSemana * qtdAlunos)) { paginaFreq++; skip = (qtdAulasSemana * (paginaFreq - 1)) * qtdAlunos; } } lkbProximo.Visible = VS_Aulas_Alunos.Skip(skip).Count() > (qtdAulasSemana * qtdAlunos); lkbAnterior.Visible = skip > 0; VS_Aulas_Alunos = VS_Aulas_Alunos.Skip(skip).Take(qtdAulasSemana * qtdAlunos).ToList(); dtInicio = VS_Aulas_Alunos.Count > 0 ? VS_Aulas_Alunos.FirstOrDefault().tau_data : capDataInicio.Date; dtFim = VS_Aulas_Alunos.Count > 0 ? VS_Aulas_Alunos.LastOrDefault().tau_data : capDataFim.Date; lblInicio.Text = dtInicio == new DateTime() ? "" : dtInicio.ToShortDateString(); lblFim.Text = dtFim == new DateTime() ? "" : dtFim.ToShortDateString(); // Carregar repeater de alunos. rptAlunosFrequencia.DataSource = MTR_MatriculaTurmaDisciplinaBO.SelecionaAlunosAtivosCOCPorTurmaDisciplina(tudId, tpcId, tipoDocente, false, capDataInicio, capDataFim, ApplicationWEB.AppMinutosCacheMedio, tur_ids) .Where(p => ((p.mtd_dataSaida > dtInicio) || (p.mtd_dataSaida == null)) && (p.mtd_dataMatricula <= dtFim)); if (entitiesControleTurma.turma.tur_tipo == (byte)TUR_TurmaTipo.Normal) { lstAlunosRelatorioRP = CLS_RelatorioPreenchimentoAlunoTurmaDisciplinaBO.SelecionaAlunoPreenchimentoPorPeriodoDisciplina(tpcId, turId, tudId, ApplicationWEB.AppMinutosCacheMedio); } this.tudTipo = entitiesControleTurma.turmaDisciplina.tud_tipo; this.permiteVisualizarCompensacao = permiteVisualizarCompensacao; this.ltPermissaoFrequencia = ltPermissaoFrequencia; this.permiteLancarFrequencia = permiteLancarFrequencia; this.permiteEdicao = false; this.situacaoTurmaDisciplina = situacaoTurmaDisciplina; this.posicaoDocente = tdtPosicao; this.usuarioPermissao = usuarioPermissao; this.periodoEfetivado = periodoEfetivado; this.periodoAberto = periodoAberto; ACA_CurriculoPeriodo entityCrp = ACA_CurriculoPeriodoBO.SelecionaPorTurmaTipoNormal(turId, ApplicationWEB.AppMinutosCacheLongo); this.crpControleTempo = entityCrp.crp_controleTempo; this.possuiRegencia = TUR_TurmaBO.VerificaPossuiDisciplinaPorTipo(turId, TurmaDisciplinaTipo.Regencia, ApplicationWEB.AppMinutosCacheLongo); this.tipoApuracaoFrequencia = entitiesControleTurma.formatoAvaliacao.fav_tipoApuracaoFrequencia; this.tne_id = tne_id; this.ttn_tipo = entitiesControleTurma.tipoTurno.ttn_tipo; rptAlunosFrequencia.DataBind(); // Limpa o hiddenfield do listão de frequência pra zerar a ordenação. hdnOrdenacaoFrequencia.Value = ""; //Fazendo as validações após carregar os dados. if (rptAlunosFrequencia.Items.Count == 0) { EscondeGridAlunosFrequencia("Não foram encontrados alunos na turma selecionada."); esconderSalvar = true; } else { MostraPeriodo(true); pnlLancamentoFrequencias.Visible = true; RepeaterItem header = (RepeaterItem)rptAlunosFrequencia.Controls[0]; Repeater rptAulas = (Repeater)header.FindControl("rptAulas"); lblMsgParecer.Visible = rptAulas.Items.Count > 0; _lblMsgRepeater.Visible = rptAulas.Items.Count == 0; if (rptAulas.Items.Count == 0) { _lblMsgRepeater.Text = UtilBO.GetErroMessage(GetGlobalResourceObject("Academico", "ControleTurma.Listao.MensagemSemAulas").ToString(), UtilBO.TipoMensagem.Alerta); esconderSalvar = true; } countAulas = rptAulas.Items.Count; rptAlunosFrequencia.Visible = true; } if (this.permiteEdicao && !periodoEfetivado) { permiteEdicao = true; } }
/// <summary> /// Processa os protocolos informados. /// </summary> /// <param name="ltProtocolo">Lista de protocolos em processamento.</param> /// <param name="tentativasProtocolo">Quantidade máxima de tentativas para processar protocolos.</param> /// <returns></returns> public static bool ProcessaProtocoloPlanejamentoAnual(List <DCL_Protocolo> ltProtocolo, int tentativasProtocolo) { // DataTable de protocolos DataTable dtProtocolo = DCL_Protocolo.TipoTabela_Protocolo(); foreach (DCL_Protocolo protocolo in ltProtocolo.Where(pro => pro.pro_tentativa > tentativasProtocolo)) { protocolo.pro_statusObservacao = String.Format("Número máximo ({0}) de tentativas de processamento deste protocolo foram excedidas. Erro: {1}" , tentativasProtocolo, protocolo.pro_statusObservacao); protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao; protocolo.tur_id = -1; protocolo.tud_id = -1; protocolo.tau_id = -1; protocolo.pro_qtdeAlunos = -1; dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow())); } foreach (DCL_Protocolo protocolo in ltProtocolo.Where(pro => pro.pro_tentativa <= tentativasProtocolo)) { // Abre uma transação para cada protocolo dentro do laço. // Assim é possível processar o próximo protocolo, mesmo que o atual esteja com erro. TalkDBTransaction bancoSincronizacao = new CLS_TurmaAulaDAO()._Banco.CopyThisInstance(); bancoSincronizacao.Open(IsolationLevel.ReadCommitted); bool processou = false; try { if (protocolo.pro_tentativa <= tentativasProtocolo) { if (string.IsNullOrEmpty(protocolo.pro_versaoAplicativo)) { throw new ValidationException("É necessário atualizar a versão do sistema."); } ///* // * na versão 44 o planejamento mudou e não mais podera mais processar // * protocolos de planejamento antigos // * */ //int minorVersion = int.Parse(protocolo.pro_versaoAplicativo.Split('.')[1]); //if (minorVersion < 44) // throw new ValidationException("É necessário atualizar a versão do sistema."); #region Varável List <CLS_TurmaDisciplinaPlanejamento> listaPlanejamento = new List <CLS_TurmaDisciplinaPlanejamento>(); #endregion #region Informações do planejamento anual // Objeto JSON de entrada. JObject planejamento = JObject.Parse(protocolo.pro_pacote); long tud_id = (long)planejamento.SelectToken("tud_id"); protocolo.tud_id = tud_id; // apenas protocolos de turmas ativas e do ano letivo corrente podem ser processados if (!DCL_ProtocoloBO.PodeProcessarProtocolo(0, tud_id)) { throw new ValidationException("O protocolo pertence a uma turma que não esta ativa ou de um ano letivo diferente do corrente, não pode ser processado!"); } ACA_CurriculoPeriodo entCrp = ACA_CurriculoPeriodoBO.SelecionaPorTurmaDisciplina(tud_id, bancoSincronizacao).FirstOrDefault(); #endregion // Todas as matrículas de aluno na disciplina. List <MTR_MatriculaTurmaDisciplina> listaMatriculas = MTR_MatriculaTurmaDisciplinaBO. SelecionaMatriculasPorTurmaDisciplina(tud_id.ToString(), bancoSincronizacao); List <CLS_AlunoTurmaDisciplinaOrientacaoCurricular> listaAlunoTurmaDisciplinaOrientacao = new List <CLS_AlunoTurmaDisciplinaOrientacaoCurricular>(); List <CLS_PlanejamentoOrientacaoCurricular> listaPlanejamentoOrientacao = new List <CLS_PlanejamentoOrientacaoCurricular>(); List <CLS_PlanejamentoOrientacaoCurricularDiagnostico> listaPlanejamentoDiagnostico = new List <CLS_PlanejamentoOrientacaoCurricularDiagnostico>(); if (!ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.PLANEJAMENTO_ANUAL_CICLO, Guid.Empty)) { #region Informações sobre alcance dos alunos nas orientações curriculares JArray alunoLista = ((JArray)planejamento.SelectToken("AlunoTurmaDisciplinaOrientacaoCurricular") ?? new JArray()); List <CLS_AlunoTurmaDisciplinaOrientacaoCurricular> listaAlunoTurmaDisciplinaOrientacaoCadastrados = CLS_AlunoTurmaDisciplinaOrientacaoCurricularBO.SelecionaAlunosPorTurmaDisciplina(tud_id, bancoSincronizacao); listaAlunoTurmaDisciplinaOrientacao = alunoLista.Count > 0 ? (from JObject aluno in alunoLista let alu_id = (long)aluno.SelectToken("alu_id") let ocr_id = (long)aluno.SelectToken("ocr_id") let tpc_id = (int)aluno.SelectToken("tpc_id") let aha_alcancada = (bool)aluno.SelectToken("aha_alcancada") let aha_efetivada = (bool)aluno.SelectToken("aha_efetivada") let dataAlteracao = Convert.ToDateTime(aluno.SelectToken("DataAlteracao") ?? new DateTime()) let entMtd = listaMatriculas.Find(p => p.alu_id == alu_id) where entMtd != null && !entMtd.IsNew let entAlunoTurmaOrientacao = listaAlunoTurmaDisciplinaOrientacaoCadastrados.Any(p => p.alu_id == entMtd.alu_id && p.mtu_id == entMtd.mtu_id && p.mtd_id == entMtd.mtd_id && p.ocr_id == ocr_id && p.tpc_id == tpc_id) ? listaAlunoTurmaDisciplinaOrientacaoCadastrados.Find(p => p.alu_id == entMtd.alu_id && p.mtu_id == entMtd.mtu_id && p.mtd_id == entMtd.mtd_id && p.ocr_id == ocr_id && p.tpc_id == tpc_id) : new CLS_AlunoTurmaDisciplinaOrientacaoCurricular() let aha_id = entAlunoTurmaOrientacao != null && entAlunoTurmaOrientacao.aha_id > 0 ? entAlunoTurmaOrientacao.aha_id : -1 select new CLS_AlunoTurmaDisciplinaOrientacaoCurricular { tud_id = tud_id , alu_id = alu_id , mtu_id = entMtd.mtu_id , mtd_id = entMtd.mtd_id , ocr_id = ocr_id , tpc_id = tpc_id , aha_id = aha_id , aha_alcancada = entAlunoTurmaOrientacao.aha_dataAlteracao > dataAlteracao ? entAlunoTurmaOrientacao.aha_alcancada : aha_alcancada , aha_efetivada = entAlunoTurmaOrientacao.aha_dataAlteracao > dataAlteracao ? entAlunoTurmaOrientacao.aha_efetivada : aha_efetivada , aha_situacao = 1 , aha_dataAlteracao = dataAlteracao , IsNew = aha_id <= 0 }).ToList() : new List <CLS_AlunoTurmaDisciplinaOrientacaoCurricular>(); #endregion #region Informações sobre planejamento das orientações curriculares nos bimestre JArray planejamentoOrientacaoLista = ((JArray)planejamento.SelectToken("PlanejamentoOrientacaoCurricular") ?? new JArray()); listaPlanejamentoOrientacao = planejamentoOrientacaoLista.Count > 0 ? (from JObject planejamentoOrientacao in planejamentoOrientacaoLista select new CLS_PlanejamentoOrientacaoCurricular { tud_id = tud_id , ocr_id = (long)planejamentoOrientacao.SelectToken("ocr_id") , tpc_id = (int)planejamentoOrientacao.SelectToken("tpc_id") , poc_planejado = (bool)planejamentoOrientacao.SelectToken("poc_planejado") , poc_trabalhado = (bool)planejamentoOrientacao.SelectToken("poc_trabalhado") , poc_alcancado = (bool)planejamentoOrientacao.SelectToken("poc_alcancado") , tdt_posicao = (byte)(planejamentoOrientacao.SelectToken("tdt_posicao") ?? 1) }).ToList() : new List <CLS_PlanejamentoOrientacaoCurricular>(); #endregion #region Informações sobre o planejamento das orientações curriculares no ano anterior JArray planejamentoOrientacaoDiagLista = ((JArray)planejamento.SelectToken("PlanejamentoOrientacaoCurricularDiagnostico") ?? new JArray()); listaPlanejamentoDiagnostico = planejamentoOrientacaoDiagLista.Count > 0 ? (from JObject diagnostico in planejamentoOrientacaoDiagLista select new CLS_PlanejamentoOrientacaoCurricularDiagnostico { tud_id = tud_id , ocr_id = (long)diagnostico.SelectToken("ocr_id") , pod_alcancado = (bool)diagnostico.SelectToken("pod_alcancado") , tdt_posicao = (byte)(diagnostico.SelectToken("tdt_posicao") ?? 1) }).ToList() : new List <CLS_PlanejamentoOrientacaoCurricularDiagnostico>(); #endregion } #region Informações sobre os planejamentos anuais e/ou bimestrais JArray TudPlanejamentoLista = ((JArray)planejamento.SelectToken("TurmaDisciplinaPlanejamento") ?? new JArray()); List <CLS_TurmaDisciplinaPlanejamento> ltPlanejamentoBanco = SelecionaListaPorTurmaDisciplina(tud_id, bancoSincronizacao); foreach (JObject turmaPlanejamento in TudPlanejamentoLista) { DateTime tdp_dataAlteracao = Convert.ToDateTime(turmaPlanejamento.SelectToken("tdp_dataAlteracao").ToString()); if (tdp_dataAlteracao > DateTime.Now.AddMinutes(10)) { throw new ValidationException("A data de alteração do planejamento é maior que a data atual."); } int tpc_id = (int)(turmaPlanejamento.SelectToken("tpc_id") ?? -1); int tdp_id = (int)turmaPlanejamento.SelectToken("tdp_id"); byte tdt_posicao = (byte)(turmaPlanejamento.SelectToken("tdt_posicao") ?? 1); CLS_TurmaDisciplinaPlanejamento planejamentoBanco = ltPlanejamentoBanco.Any(p => p.tud_id == tud_id && p.tdp_id == tdp_id && p.tdt_posicao == tdt_posicao) ? ltPlanejamentoBanco.Find(p => p.tud_id == tud_id && p.tdp_id == tdp_id && p.tdt_posicao == tdt_posicao) : new CLS_TurmaDisciplinaPlanejamento(); planejamentoBanco.IsNew = planejamentoBanco.tdp_id <= 0; string tdp_planejamento = (turmaPlanejamento.SelectToken("tdp_planejamento") ?? string.Empty).ToString(); string tdp_diagnostico = (turmaPlanejamento.SelectToken("tdp_diagnostico") ?? string.Empty).ToString(); string tdp_avaliacaoTrabalho = (turmaPlanejamento.SelectToken("tdp_avaliacaoTrabalho") ?? string.Empty).ToString(); string tdp_recursos = (turmaPlanejamento.SelectToken("tdp_recursos") ?? string.Empty).ToString(); string tdp_intervencoesPedagogicas = (turmaPlanejamento.SelectToken("tdp_intervencoesPedagogicas") ?? string.Empty).ToString(); string tdp_registroIntervencoes = (turmaPlanejamento.SelectToken("tdp_registroIntervencoes") ?? string.Empty).ToString(); CLS_TurmaDisciplinaPlanejamento entPlanejamento = new CLS_TurmaDisciplinaPlanejamento(); if (!planejamentoBanco.IsNew) { entPlanejamento = planejamentoBanco; } else { entPlanejamento = new CLS_TurmaDisciplinaPlanejamento { tud_id = tud_id , tdp_id = -1 , tpc_id = tpc_id , tdt_posicao = (byte)(turmaPlanejamento.SelectToken("tdt_posicao") ?? 1) , tdp_situacao = 1 , pro_id = protocolo.pro_id }; } entPlanejamento.tdp_planejamento = RetornaValorTextoSincronizacao(tdp_planejamento, tdp_dataAlteracao, planejamentoBanco.tdp_planejamento, planejamentoBanco.tdp_dataAlteracao); entPlanejamento.tdp_diagnostico = RetornaValorTextoSincronizacao(tdp_diagnostico, tdp_dataAlteracao, planejamentoBanco.tdp_diagnostico, planejamentoBanco.tdp_dataAlteracao); entPlanejamento.tdp_avaliacaoTrabalho = RetornaValorTextoSincronizacao(tdp_avaliacaoTrabalho, tdp_dataAlteracao, planejamentoBanco.tdp_avaliacaoTrabalho, planejamentoBanco.tdp_dataAlteracao); entPlanejamento.tdp_recursos = RetornaValorTextoSincronizacao(tdp_recursos, tdp_dataAlteracao, planejamentoBanco.tdp_recursos, planejamentoBanco.tdp_dataAlteracao); entPlanejamento.tdp_intervencoesPedagogicas = RetornaValorTextoSincronizacao(tdp_intervencoesPedagogicas, tdp_dataAlteracao, planejamentoBanco.tdp_intervencoesPedagogicas, planejamentoBanco.tdp_dataAlteracao); entPlanejamento.tdp_registroIntervencoes = RetornaValorTextoSincronizacao(tdp_registroIntervencoes, tdp_dataAlteracao, planejamentoBanco.tdp_registroIntervencoes, planejamentoBanco.tdp_dataAlteracao); entPlanejamento.cur_id = entCrp.cur_id; entPlanejamento.crr_id = entCrp.crr_id; entPlanejamento.crp_id = entCrp.crp_id; entPlanejamento.tdp_dataAlteracao = tdp_dataAlteracao; listaPlanejamento.Add(entPlanejamento); } #endregion if (!ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.PLANEJAMENTO_ANUAL_CICLO, Guid.Empty)) { #region Salvar alcance dos alunos nas orientações curriculares processou = CLS_AlunoTurmaDisciplinaOrientacaoCurricularBO.Salvar(listaAlunoTurmaDisciplinaOrientacao, bancoSincronizacao, true); #endregion } #region Salvar os planejamentos anuais e bimestrais processou |= CLS_PlanejamentoOrientacaoCurricularBO.SalvaPlanejamentoTurmaDisciplina(listaPlanejamento, listaPlanejamentoOrientacao, listaPlanejamentoDiagnostico, bancoSincronizacao, true); #endregion } if (processou) { // Processou com sucesso. protocolo.pro_statusObservacao = String.Format("Protocolo processado com sucesso ({0}).", DateTime.Now.ToString("dd/MM/yyyy HH:mm")); protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComSucesso; } else { if (protocolo.pro_tentativa > tentativasProtocolo) { throw new ValidationException(String.Format("Número máximo ({0}) de tentativas de processamento deste protocolo foram excedidas. Erro: {1}" , tentativasProtocolo, protocolo.pro_statusObservacao)); } // Não processou sem erro - volta o protocolo para não processado. protocolo.pro_statusObservacao = String.Format("Protocolo não processado ({0}).", DateTime.Now.ToString("dd/MM/yyyy hh:mm")); protocolo.tur_id = -1; protocolo.tud_id = -1; protocolo.tau_id = -1; protocolo.pro_qtdeAlunos = -1; protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.NaoProcessado; } dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow())); } catch (ArgumentException ex) { // Se ocorrer uma excessão de validação, guardar novo status. protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao; protocolo.pro_statusObservacao = ex.Message; protocolo.tur_id = -1; protocolo.tud_id = -1; protocolo.tau_id = -1; protocolo.pro_qtdeAlunos = -1; dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow())); bancoSincronizacao.Close(ex); } catch (ValidationException ex) { // Se ocorrer uma excessão de validação, guardar novo status. protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao; protocolo.pro_statusObservacao = ex.Message; protocolo.tur_id = -1; protocolo.tud_id = -1; protocolo.tau_id = -1; protocolo.pro_qtdeAlunos = -1; dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow())); bancoSincronizacao.Close(ex); } catch (Exception ex) { // Se ocorrer uma excessão de erro, guardar novo status. protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErro; protocolo.pro_statusObservacao = ex.Message; protocolo.tur_id = -1; protocolo.tud_id = -1; protocolo.tau_id = -1; protocolo.pro_qtdeAlunos = -1; dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow())); bancoSincronizacao.Close(ex); } finally { if (bancoSincronizacao.ConnectionIsOpen) { bancoSincronizacao.Close(); } } } DCL_ProtocoloBO.AtualizaProtocolos(dtProtocolo); return(true); }
/// <summary> /// Salva as notas das atividades extraclasse /// </summary> /// <param name="lstTurmaAtividadeExtraClasseAluno"></param> /// <returns></returns> public static bool SalvarEmLote(List <CLS_TurmaAtividadeExtraClasseAluno> lstTurmaAtividadeExtraClasseAluno, long tud_id, int tpc_id, byte tud_tipo, bool fechamentoAutomatico, Guid ent_id, List <CLS_TurmaAtividadeExtraClasse> lstRelacionamento, long tur_id) { TalkDBTransaction banco = new CLS_TurmaAtividadeExtraClasseAlunoDAO()._Banco.CopyThisInstance(); banco.Open(IsolationLevel.ReadCommitted); try { List <long> lstTudId = new List <long>(); foreach (CLS_TurmaAtividadeExtraClasse atividade in lstRelacionamento) { List <CLS_TurmaAtividadeExtraClasse> lstRelacionadas = CLS_TurmaAtividadeExtraClasseBO.SelecionaAtividadeExtraclasseRelacionada(atividade.taer_id); List <CLS_TurmaAtividadeExtraClasseAluno> lstLancamento = lstTurmaAtividadeExtraClasseAluno.FindAll(p => p.tud_id == atividade.tud_id && p.tae_id == atividade.tae_id); List <MTR_MatriculaTurmaDisciplina> lstMatriculaDisciplina = new List <MTR_MatriculaTurmaDisciplina>(); lstRelacionadas.FindAll(p => p.tud_id != atividade.tud_id || p.tae_id != atividade.tae_id).ForEach(p => { if (!lstMatriculaDisciplina.Any(m => m.tud_id == p.tud_id)) { lstMatriculaDisciplina.AddRange(MTR_MatriculaTurmaDisciplinaBO.SelecionaMatriculasPorTurmaDisciplina(p.tud_id.ToString(), banco)); } lstLancamento.ForEach(a => { CLS_TurmaAtividadeExtraClasseAluno ent = new CLS_TurmaAtividadeExtraClasseAluno { tud_id = p.tud_id, tae_id = p.tae_id, alu_id = a.alu_id, mtu_id = a.mtu_id, mtd_id = lstMatriculaDisciplina.Find(m => m.alu_id == a.alu_id && m.mtu_id == a.mtu_id && m.tud_id == p.tud_id).mtd_id, aea_avaliacao = a.aea_avaliacao, aea_relatorio = a.aea_relatorio, aea_entregue = a.aea_entregue, aea_dataAlteracao = a.aea_dataAlteracao, aea_situacao = 1 }; lstTurmaAtividadeExtraClasseAluno.Add(ent); }); if (!lstTudId.Any(t => t == p.tud_id)) { lstTudId.Add(p.tud_id); } }); } using (DataTable dt = lstTurmaAtividadeExtraClasseAluno.Select(p => new TipoTabela_TurmaAtividadeExtraClasseALuno(p).ToDataRow()).CopyToDataTable()) { CLS_TurmaAtividadeExtraClasseAlunoDAO dao = new CLS_TurmaAtividadeExtraClasseAlunoDAO(); dao._Banco = banco; if (dao.SalvarEmLote(dt)) { // Caso o fechamento seja automático, grava na fila de processamento. if (fechamentoAutomatico && tud_tipo != (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia && tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id)) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(tud_id, tpc_id, banco); } if (lstTudId.Any()) { List <TUR_TurmaDisciplina> turmaDisciplina = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, null, GestaoEscolarUtilBO.MinutosCacheLongo); lstTudId.ForEach(p => { if (fechamentoAutomatico && turmaDisciplina.Find(t => t.tud_id == p).tud_tipo != (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia && tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id)) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(p, tpc_id, banco); } } ); } return(true); } return(false); } } catch (Exception ex) { banco.Close(ex); throw; } finally { if (banco.ConnectionIsOpen) { banco.Close(); } } }
/// <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> /// 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); }
/// <summary> /// Processa os protocolos informados. /// </summary> /// <param name="ltProtocolo">Lista de protocolos em processamento.</param> /// <param name="tentativasProtocolo">Quantidade máxima de tentativas para processar protocolos.</param> /// <returns></returns> public static bool ProcessarProtocoloCompensacao(List <DCL_Protocolo> ltProtocolo, int tentativasProtocolo) { DataTable dtProtocolo = DCL_Protocolo.TipoTabela_Protocolo(); foreach (DCL_Protocolo protocolo in ltProtocolo.Where(pro => pro.pro_tentativa > tentativasProtocolo)) { protocolo.pro_statusObservacao = String.Format("Número máximo ({0}) de tentativas de processamento deste protocolo foram excedidas. Erro: {1}" , tentativasProtocolo, protocolo.pro_statusObservacao); protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao; protocolo.tur_id = -1; protocolo.tud_id = -1; protocolo.tau_id = -1; protocolo.pro_qtdeAlunos = -1; dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow())); } foreach (DCL_Protocolo protocolo in ltProtocolo.Where(pro => pro.pro_tentativa <= tentativasProtocolo)) { // Abre uma transação para cada protocolo dentro do laço. // Assim é possível processar o próximo protocolo, mesmo que o atual esteja com erro. TalkDBTransaction bancoSincronizacao = new CLS_TurmaAulaDAO()._Banco.CopyThisInstance(); bancoSincronizacao.Open(IsolationLevel.ReadCommitted); bool processou = false; try { if (protocolo.pro_tentativa <= tentativasProtocolo) { JObject json = JObject.Parse(protocolo.pro_pacote); JArray compensacoes = ((JArray)json.SelectToken("CompensacaoFalta") ?? new JArray()); foreach (JObject compensacao in compensacoes) { long tud_id = Convert.ToInt64(compensacao.SelectToken("tud_id")); ACA_FormatoAvaliacao formatoAvaliacao = ACA_FormatoAvaliacaoBO.CarregarPorTud(tud_id); ACA_CalendarioAnual cal = ACA_CalendarioAnualBO.SelecionaPorTurmaDisciplina(tud_id, bancoSincronizacao); // apenas protocolos de turmas ativas e do ano letivo corrente podem ser processados if (!DCL_ProtocoloBO.PodeProcessarProtocolo(0, tud_id)) { throw new ValidationException("O protocolo pertence a uma turma que não esta ativa ou de um ano letivo diferente do corrente, não pode ser processado!"); } int cpa_id = Convert.ToInt32(compensacao.SelectToken("cpa_id")); int quantidadeAulasCompensadas = Convert.ToInt32(compensacao.SelectToken("cpa_quantidadeAulasCompensadas")); DateTime cpa_dataAlteracao = Convert.ToDateTime(compensacao.SelectToken("cpa_dataAlteracao")); CLS_CompensacaoAusencia compensacaoAusencia; long pro_protocoloCriacao = (long)(compensacao.GetValue("pro_protocolo", StringComparison.OrdinalIgnoreCase) ?? "0"); if (cpa_id > 0 || pro_protocoloCriacao <= 0) { compensacaoAusencia = new CLS_CompensacaoAusencia { tud_id = tud_id, cpa_id = cpa_id }; GetEntity(compensacaoAusencia, bancoSincronizacao); } else { List <DCL_Protocolo> protocoloCriacaoCompensacao = DCL_ProtocoloBO.SelectBy_Protocolos(pro_protocoloCriacao.ToString()); Guid pro_idCriacao = protocoloCriacaoCompensacao.Count() > 0 ? protocoloCriacaoCompensacao[0].pro_id : Guid.Empty; compensacaoAusencia = SelectByDisciplinaProtocolo(tud_id, pro_idCriacao); if (!compensacaoAusencia.IsNew) { compensacaoAusencia.pro_id = protocolo.pro_id; } } if (compensacaoAusencia.IsNew) { compensacaoAusencia.cpa_id = -1; compensacaoAusencia.cpa_dataCriacao = DateTime.Now; compensacaoAusencia.pro_id = protocolo.pro_id; } else if (!compensacaoAusencia.IsNew && (cpa_dataAlteracao < compensacaoAusencia.cpa_dataAlteracao)) { throw new ValidationException("Compensação existe e foi alterada mais recentemente."); } compensacaoAusencia.tpc_id = Convert.ToInt32(compensacao.SelectToken("tpc_id")); compensacaoAusencia.cpa_quantidadeAulasCompensadas = quantidadeAulasCompensadas; compensacaoAusencia.cpa_atividadesDesenvolvidas = Convert.ToString(compensacao.SelectToken("cpa_atividadesDesenvolvidas")); compensacaoAusencia.cpa_situacao = Convert.ToInt16(compensacao.SelectToken("cpa_situacao")); compensacaoAusencia.cpa_dataAlteracao = DateTime.Now; if (compensacaoAusencia.cpa_situacao != 3) { JArray arrayAlunos = ((JArray)compensacao.SelectToken("AlunosCompensados") ?? new JArray()); List <CLS_CompensacaoAusenciaAluno> listaAlunos = new List <CLS_CompensacaoAusenciaAluno>(); foreach (JObject jsonAluno in arrayAlunos) { int alu_id = Convert.ToInt32(jsonAluno.SelectToken("alu_id")); MTR_MatriculaTurmaDisciplina matricula = MTR_MatriculaTurmaDisciplinaBO.BuscarPorAlunoTurmaDisciplina(alu_id, tud_id, bancoSincronizacao); CLS_CompensacaoAusenciaAluno compensacaoAluno = new CLS_CompensacaoAusenciaAluno { tud_id = tud_id, cpa_id = compensacaoAusencia.cpa_id, alu_id = alu_id, mtu_id = matricula.mtu_id, mtd_id = matricula.mtd_id }; CLS_CompensacaoAusenciaAlunoBO.GetEntity(compensacaoAluno); if (compensacaoAluno.IsNew) { compensacaoAluno.caa_dataCriacao = DateTime.Now; } compensacaoAluno.caa_situacao = 1; compensacaoAluno.caa_dataAlteracao = DateTime.Now; listaAlunos.Add(compensacaoAluno); } processou = Save(compensacaoAusencia, listaAlunos, formatoAvaliacao.fav_fechamentoAutomatico, cal.cal_id, bancoSincronizacao); } else { // persistindo os dados. processou = true; // Caso o fechamento seja automático, grava na fila de processamento. if (formatoAvaliacao.fav_fechamentoAutomatico && compensacaoAusencia.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, new Guid())) { processou &= CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(compensacaoAusencia.tud_id, compensacaoAusencia.tpc_id, bancoSincronizacao); } processou &= Delete(compensacaoAusencia, bancoSincronizacao); } } } // Processou com sucesso. protocolo.pro_statusObservacao = String.Format("Protocolo processado com sucesso ({0}).", DateTime.Now.ToString("dd/MM/yyyy HH:mm")); protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComSucesso; dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow())); } catch (ArgumentException ex) { // Se ocorrer uma excessão de validação, guardar novo status. protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao; protocolo.pro_statusObservacao = ex.Message; protocolo.tur_id = -1; protocolo.tud_id = -1; protocolo.tau_id = -1; protocolo.pro_qtdeAlunos = -1; dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow())); bancoSincronizacao.Close(ex); } catch (ValidationException ex) { // Se ocorrer uma excessão de validação, guardar novo status. protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErrosValidacao; protocolo.pro_statusObservacao = ex.Message; protocolo.tur_id = -1; protocolo.tud_id = -1; protocolo.tau_id = -1; protocolo.pro_qtdeAlunos = -1; dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow())); bancoSincronizacao.Close(ex); } catch (Exception ex) { // Se ocorrer uma excessão de erro, guardar novo status. protocolo.pro_status = (byte)DCL_ProtocoloBO.eStatus.ProcessadoComErro; protocolo.pro_statusObservacao = ex.Message; protocolo.tur_id = -1; protocolo.tud_id = -1; protocolo.tau_id = -1; protocolo.pro_qtdeAlunos = -1; dtProtocolo.Rows.Add(DCL_ProtocoloBO.ProtocoloToDataRow(protocolo, dtProtocolo.NewRow())); bancoSincronizacao.Close(ex); } finally { if (bancoSincronizacao.ConnectionIsOpen) { bancoSincronizacao.Close(); } } } DCL_ProtocoloBO.AtualizaProtocolos(dtProtocolo); return(true); }
/// <summary> /// Override do Save passando o banco - salva tambem a tabela CLS_CompensacaoAusenciaAluno /// </summary> /// <param name="entity">Entidade a ser salva</param> /// <param name="lista">Lista de CLS_CompensacaoAusenciaAluno a ser salva</param> /// <param name="fechamentoAutomatico">Indica se o fechamento é automático.</param> /// <param name="banco">Transação com banco</param> /// <returns>Se salvou com sucesso</returns> public static bool Save(CLS_CompensacaoAusencia entity, List <CLS_CompensacaoAusenciaAluno> lista, bool fechamentoAutomatico, int cal_id, TalkDBTransaction banco) { // permite cadatrar compensacao apenas para o ultimo periodo aberto, // o metodo ja retorna os periodos abertos ordenados do mais recente para o mais antigo List <sComboPeriodoCalendario> dtPeriodos = ACA_TipoPeriodoCalendarioBO.SelecionaPor_PeriodoVigente_EventoEfetivacaoVigente(-1, entity.tud_id, -1, Guid.Empty, true); if (dtPeriodos.Count > 0 && dtPeriodos.Any(p => p.tpc_id == entity.tpc_id)) { //validacoes DataTable dt = MTR_MatriculaTurmaDisciplinaBO.SelecionaAtivosCompensacaoAusencia( entity.tud_id, entity.tpc_id, 0, entity.cpa_id ); dt.PrimaryKey = new DataColumn[1] { dt.Columns["alu_id"] }; TUR_TurmaDisciplina turmaDisciplina = TUR_TurmaDisciplinaBO.GetEntity(new TUR_TurmaDisciplina { tud_id = entity.tud_id }); // se for disciplina especial if (turmaDisciplina.tud_disciplinaEspecial // e o docente do tipo especial tem permissao de editar a compensacao && CFG_PermissaoDocenteBO.SelecionaPermissaoModulo((byte)EnumTipoDocente.Especial, (byte)EnumModuloPermissao.Compensacoes).Any(p => p.pdc_permissaoEdicao)) { // adiciono na lista de validacao os aluno especiais DataTable dtEspecial = MTR_MatriculaTurmaDisciplinaBO.SelecionaAtivosCompensacaoAusenciaFiltroDeficiencia( -1, entity.tud_id, entity.tpc_id, 0, EnumTipoDocente.Especial, entity.cpa_id); dt.Merge(dtEspecial, false, MissingSchemaAction.AddWithKey); } bool valida = true; string msgValidacao = ""; if (turmaDisciplina.tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia) { if (!TUR_TurmaDisciplinaTerritorioBO.VerificaOferecimentoExperienciaBimestre(turmaDisciplina.tud_id, cal_id, entity.tpc_id)) { valida = false; msgValidacao += "A experiência não possui territórios vigentes no bimestre."; } } // caso exista alguma compensação já criada pro aluno // valida se pode existir alguma outra. foreach (CLS_CompensacaoAusenciaAluno cpaa in lista) { var results = from row in dt.AsEnumerable() where row.Field <Int64>("alu_id") == cpaa.alu_id select row; if (results.Count() > 0) { DataTable aux = results.CopyToDataTable(); int totalFaltasCompensar = Convert.ToInt32(aux.Rows[0]["TotalFaltasCompensar"]); if (entity.cpa_quantidadeAulasCompensadas > totalFaltasCompensar) { valida = false; msgValidacao += String.Format("Aluno(a) {0} não pode ter essa quantidade de ausências compensadas. </br>", aux.Rows[0]["pes_nome"].ToString()); } } else { valida = false; ACA_Aluno aluno = ACA_AlunoBO.GetEntity(new ACA_Aluno { alu_id = cpaa.alu_id }); PES_Pessoa pes = PES_PessoaBO.GetEntity(new PES_Pessoa { pes_id = aluno.pes_id }); msgValidacao += String.Format("Aluno(a) {0} não pode ter ausências compensadas nos bimestres em que não estava na turma. </br>", pes.pes_nome); } } if (!valida) { throw new ValidationException(msgValidacao); } // Salva CLS_CompensacaoAusencia if (!Save(entity, banco)) { throw new Exception("Erro ao tentar salvar compensação de ausência."); } // Caso o fechamento seja automático, grava na fila de processamento. if (fechamentoAutomatico && entity.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, new Guid())) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(entity.tud_id, entity.tpc_id, banco); } List <CLS_CompensacaoAusenciaAluno> listaBanco = CLS_CompensacaoAusenciaAlunoBO.SelectByCpa_id(entity.cpa_id, entity.tud_id); foreach (CLS_CompensacaoAusenciaAluno item in lista) { CLS_CompensacaoAusenciaAluno ent = listaBanco.Find(p => p.tud_id == item.tud_id && p.cpa_id == entity.cpa_id && p.alu_id == item.alu_id && p.mtd_id == item.mtd_id && p.mtu_id == item.mtu_id); if (ent != null) { // Achou na lista que vem no banco, altera. ent.IsNew = false; CLS_CompensacaoAusenciaAlunoBO.Save(ent, banco); // Remove o registro da lista do banco para restar somente os que serao excluidos. listaBanco.Remove(ent); } else { // Não achou na lista do banco, inclui. item.cpa_id = entity.cpa_id; CLS_CompensacaoAusenciaAlunoBO.GetEntity(item, banco); if (item.caa_situacao == 3) { item.caa_situacao = 1; item.IsNew = false; } else { item.IsNew = true; } CLS_CompensacaoAusenciaAlunoBO.Save(item, banco); } } if (listaBanco.Count > 0) { foreach (CLS_CompensacaoAusenciaAluno item in listaBanco) { CLS_CompensacaoAusenciaAlunoBO.Delete(item, banco); } } } else { throw new ValidationException("Não existe evento de fechamento do bimestre aberto para realizar o lançamento."); } 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, 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(); } } }
/// <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(); } } }