/// <summary> /// Salva as justificativas de pendencia em lote. /// </summary> /// <param name="dtFechamentoJustificativaPendencia">Tabela com os dados das justificativas.</param> /// <returns></returns> public static bool SalvarEmLote(List <CLS_FechamentoJustificativaPendencia> lstFechamentoJustificativaPendencia) { CLS_FechamentoJustificativaPendenciaDAO dao = new CLS_FechamentoJustificativaPendenciaDAO(); TalkDBTransaction banco = dao._Banco.CopyThisInstance(); banco.Open(IsolationLevel.ReadCommitted); try { DataTable dtFechamentoJustificativaPendencia = CLS_FechamentoJustificativaPendencia.TipoTabela_FechamentoJustificativaPendencia(); lstFechamentoJustificativaPendencia.ForEach(p => { DataRow drFechamentoJustificativaPendencia = dtFechamentoJustificativaPendencia.NewRow(); dtFechamentoJustificativaPendencia.Rows.Add(EntityToDataRow(p, drFechamentoJustificativaPendencia)); }); if (new CLS_FechamentoJustificativaPendenciaDAO { _Banco = banco }.SalvarEmLote(dtFechamentoJustificativaPendencia) // Se tiver registro de inserção na tabela, atualizo a lista de pendências no fechamento. && lstFechamentoJustificativaPendencia.Any(p => p.fjp_id <= 0)) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias( lstFechamentoJustificativaPendencia .Select(p => new AlunoFechamentoPendencia { tud_id = p.tud_id, tpc_id = p.tpc_id, afp_frequencia = false, afp_nota = false, afp_processado = 2 }) .ToList() , banco); } // Limpa o cache. try { if (lstFechamentoJustificativaPendencia.Count > 0 && HttpContext.Current != null) { lstFechamentoJustificativaPendencia.ForEach(p => GestaoEscolarUtilBO.LimpaCache(string.Format(ModelCache.FECHAMENTO_JUSTIFICATIVA_PENDENCIA_MODEL_KEY, p.tud_id, p.cal_id, p.tpc_id))); } } catch { } return(true); } catch (Exception err) { banco.Close(err); throw; } finally { banco.Close(); } }
public new static bool Delete(CLS_CompensacaoAusencia entity) { CLS_CompensacaoAusenciaDAO dao = new CLS_CompensacaoAusenciaDAO(); dao._Banco.Open(IsolationLevel.ReadCommitted); try { ACA_FormatoAvaliacao formatoAvaliacao = ACA_FormatoAvaliacaoBO.CarregarPorTud(entity.tud_id); // Caso o fechamento seja automático, grava na fila de processamento. if (formatoAvaliacao.fav_fechamentoAutomatico && entity.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, new Guid())) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(entity.tud_id, entity.tpc_id, dao._Banco); } CLS_CompensacaoAusenciaAlunoDAO daoAluno = new CLS_CompensacaoAusenciaAlunoDAO { _Banco = dao._Banco }; List <CLS_CompensacaoAusenciaAluno> listaBanco = daoAluno.SelectByCpa_id(entity.cpa_id, entity.tud_id); foreach (CLS_CompensacaoAusenciaAluno item in listaBanco) { if (!daoAluno.Delete(item)) { throw new Exception("Erro ao tentar excluir compensação de ausência do aluno."); } } // Exclui CLS_CompensacaoAusencia if (!dao.Delete(entity)) { throw new Exception("Erro ao tentar excluir compensação de ausência."); } return(true); } catch (Exception err) { dao._Banco.Close(err); throw err; } finally { //Fechamento da transação dao._Banco.Close(); } }
public static bool Excluir(CLS_FechamentoJustificativaPendencia fechamentoJustificativaPendencia) { CLS_FechamentoJustificativaPendenciaDAO dao = new CLS_FechamentoJustificativaPendenciaDAO(); TalkDBTransaction banco = dao._Banco.CopyThisInstance(); banco.Open(IsolationLevel.ReadCommitted); try { if (CLS_FechamentoJustificativaPendenciaBO.Delete(fechamentoJustificativaPendencia, banco)) { // Atualizo a lista de pendências no fechamento. CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias( new List <AlunoFechamentoPendencia> { new AlunoFechamentoPendencia { tud_id = fechamentoJustificativaPendencia.tud_id, tpc_id = fechamentoJustificativaPendencia.tpc_id, afp_frequencia = false, afp_nota = false, afp_processado = 2 } } , banco); } // Limpa o cache. try { if (HttpContext.Current != null) { GestaoEscolarUtilBO.LimpaCache(string.Format(ModelCache.FECHAMENTO_JUSTIFICATIVA_PENDENCIA_MODEL_KEY, fechamentoJustificativaPendencia.tud_id, fechamentoJustificativaPendencia.cal_id, fechamentoJustificativaPendencia.tpc_id)); } } catch { } return(true); } catch (Exception err) { banco.Close(err); throw; } finally { banco.Close(); } }
public static bool Salvar(List <CLS_AlunoFrequenciaExterna> lstAlunoFrequenciaExterna, int fav_id, Guid ent_id) { TalkDBTransaction banco = new CLS_AlunoFrequenciaExternaDAO()._Banco.CopyThisInstance(); List <AlunoFechamentoPendencia> FilaProcessamento = new List <AlunoFechamentoPendencia>(); try { if (lstAlunoFrequenciaExterna.Aggregate(true, (salvou, freq) => salvou & Save(freq, banco))) { ACA_FormatoAvaliacao entFormatoAvaliacao = new ACA_FormatoAvaliacao { fav_id = fav_id }; ACA_FormatoAvaliacaoBO.GetEntity(entFormatoAvaliacao, banco); if (entFormatoAvaliacao.fav_fechamentoAutomatico) { FilaProcessamento.AddRange (lstAlunoFrequenciaExterna.GroupBy(p => new { p.tud_id, p.tpc_id }) .Select(p => new AlunoFechamentoPendencia { tud_id = p.Key.tud_id , tpc_id = p.Key.tpc_id , afp_frequencia = false , afp_nota = false , afp_frequenciaExterna = true , afp_processado = 0 }) ); if (FilaProcessamento.Any()) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequenciaExterna( 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_frequenciaExterna = p.FirstOrDefault().afp_frequenciaExterna, 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); } return(false); } catch (Exception ex) { banco.Close(ex); throw; } finally { if (banco.ConnectionIsOpen) { banco.Close(); } } }
/// <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); }
/// <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 a lista de aulas previstas, validando as entidades. /// </summary> /// <param name="lista"></param> /// <returns></returns> public static bool SalvarAulasPrevistas(List <TUR_TurmaDisciplinaAulaPrevista> lista, List <TUR_TurmaDisciplinaAulaPrevista> listaProcessarPend, Guid ent_id, int esc_id, long doc_id, bool fechamentoAutomatico) { TalkDBTransaction banco = new TUR_TurmaDisciplinaAulaPrevistaDAO()._Banco.CopyThisInstance(); try { banco.Open(); bool ret = true; foreach (TUR_TurmaDisciplinaAulaPrevista entity in lista) { if (!entity.Validate()) { throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity)); } ret &= Save(entity, banco); } foreach (var listaTudTpc in listaProcessarPend.Select(tap => new { tap.tud_id, tap.tud_tipo, tap.tpc_id }).Distinct()) { // Caso o fechamento seja automático, grava na fila de processamento. if (fechamentoAutomatico && listaProcessarPend.Count > 0 && listaTudTpc.tud_tipo != (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia && listaTudTpc.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id)) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(listaTudTpc.tud_id, listaTudTpc.tpc_id, banco); } } if (lista.Count > 0 && ret && HttpContext.Current != null) { try { // Limpa o cache da lista de turmas, para atualizar o check string chave = TUR_TurmaBO.RetornaChaveCache_GestorMinhaEscola(ent_id, esc_id); HttpContext.Current.Cache.Remove(chave); if (doc_id > 0) { chave = TUR_TurmaBO.RetornaChaveCache_DocenteControleTurmas(ent_id, doc_id); HttpContext.Current.Cache.Remove(chave); } else { GestaoEscolarUtilBO.LimpaCache(string.Format("{0}_{1}", TUR_TurmaDisciplinaBO.Cache_SelecionaPorDocenteControleTurma, ent_id)); } // Limpa o cache do fechamento long tud_id = lista[0].tud_id; GestaoEscolarUtilBO.LimpaCache(ModelCache.FECHAMENTO_BIMESTRE_PATTERN_KEY, tud_id.ToString()); GestaoEscolarUtilBO.LimpaCache(ModelCache.FECHAMENTO_BIMESTRE_FILTRO_DEFICIENCIA_PATTERN_KEY, tud_id.ToString()); GestaoEscolarUtilBO.LimpaCache(string.Format(ModelCache.TURMA_DISCIPLINA_AULA_PREVISTA_MODEL_KEY, tud_id)); GestaoEscolarUtilBO.LimpaCache(string.Format(ModelCache.TURMA_SELECIONA_POR_DOCENTE_CONTROLE_TURMA_MODEL_KEY, ent_id.ToString(), doc_id.ToString())); } catch { } } return(ret); } catch (Exception ex) { banco.Close(ex); throw ex; } finally { banco.Close(); } }
/// <summary> /// Gera as aulas do planejamento diário. /// </summary> /// <param name="tagsSalvar">Lista de CLS_TurmaAulaGerada para gravar</param> /// <param name="doc_id">Docente para quem devem ser geradas as CLS_TurmaAula correspondentes</param> /// <param name="usu_id">ID do usuário logado.</param> /// <param name="ent_id">ID da entidade do usuário logado</param> /// <param name="gerouTodasAulas">Flag que indica se todas as aulas foram salvas.</param> /// <param name="ultrapassouCargaHorariaSemanal">Lista de alertas para os itens que não foram plenamente atendidos.</param> /// <returns></returns> public static bool GerarAulasPlanejamentoDiario ( List <CLS_TurmaAulaGerada> tagsSalvar, int tpc_id, long doc_id, DateTime?dataInicial, DateTime?dataFinal, Guid usu_id, Guid ent_id, Dictionary <long, string> dicTurmasDisciplinas, out bool gerouTodasAulas, out Dictionary <long, string> ultrapassouCargaHorariaSemanal, out Dictionary <long, string> semVigencia, out Dictionary <long, string> semAulasPrevistas, out Dictionary <long, Exception> outrosErros, byte origemLogAula = 0 ) { gerouTodasAulas = true; ultrapassouCargaHorariaSemanal = new Dictionary <long, string>(); semVigencia = new Dictionary <long, string>(); semAulasPrevistas = new Dictionary <long, string>(); outrosErros = new Dictionary <long, Exception>(); Dictionary <long, string> ultrapassouCargaHorariaSemanalTerritorio = new Dictionary <long, string>(); // armazenará os períodos de cada calendário var dicPeriodosCalendario = new Dictionary <int, DataTable>(); // armazenará os dias não-úteis de cada escola var dicDiasNaoUteis = new Dictionary <int, List <DateTime> >(); DateTime dataLimiteLancamento = new DateTime(); string dataBloqueio = ACA_ParametroAcademicoBO.ParametroValorPorEntidade(eChaveAcademico.DATA_VALIDADE_BLOQUEIO_ACESSO_MINHAS_TURMAS, ent_id); if (!string.IsNullOrEmpty(dataBloqueio)) { if (!DateTime.TryParse(dataBloqueio, out dataLimiteLancamento)) { dataLimiteLancamento = new DateTime(); } //throw new ValidationException("A data de bloqueio informada no parâmetro não é válida."); } #region Valida itens que bloqueiam toda a execução e preenche listas de calendários // utilizadas na verificação de carga horária semanal, cuja soma precisa ser verificada por tud_id long tud_id_anterior = 0; int tud_cargaHorariaSemanal = 0; foreach (var tag in tagsSalvar.OrderBy(tag => tag.tud_id)) { if (tud_id_anterior != tag.tud_id) { tud_id_anterior = tag.tud_id; tud_cargaHorariaSemanal = 0; } tud_cargaHorariaSemanal += tag.tag_numeroAulas; if (tud_cargaHorariaSemanal > tag.tud_cargaHorariaSemanal) { throw new ValidationException(string.Format("{0} excede a carga horária semanal permitida.", dicTurmasDisciplinas[tag.tud_id])); } var cap_dataInicio = new DateTime(); var cap_dataFim = new DateTime(); #region Preenche as listas de calendários, cap_dataInicio e cap_dataFim DataTable cal = null; if (dicPeriodosCalendario.Any(i => i.Key == tag.cal_id)) { cal = dicPeriodosCalendario.First(i => i.Key == tag.cal_id).Value; } else { cal = ACA_TipoPeriodoCalendarioBO.SelecionaTipoPeriodoCalendarioPorTipoPeriodoCalendario(tpc_id, tag.cal_id); dicPeriodosCalendario.Add(tag.cal_id, cal); } cap_dataInicio = Convert.ToDateTime(cal.Rows[0]["cap_dataInicio"]); cap_dataFim = Convert.ToDateTime(cal.Rows[0]["cap_dataFim"]); if (!dicDiasNaoUteis.Any(i => i.Key == tag.esc_id)) { dicDiasNaoUteis.Add(tag.esc_id, ACA_CalendarioPeriodoBO.SelecionaDiasNaoUteis(tag.esc_id, tag.uni_id, tag.cal_id, cap_dataInicio, cap_dataFim, ent_id)); } #endregion if (dataInicial.HasValue && (dataInicial < cap_dataInicio || dataInicial > cap_dataFim)) { throw new ArgumentException(String.Format(CustomResource.GetGlobalResourceObject("BLL", "TurmaAula.ValidaDataInicioBimestre"), cap_dataInicio.ToShortDateString(), cap_dataFim.ToShortDateString())); } if (dataFinal.HasValue && (dataFinal < cap_dataInicio || dataFinal > cap_dataFim)) { throw new ArgumentException(String.Format(CustomResource.GetGlobalResourceObject("BLL", "TurmaAula.ValidaDataFimBimestre"), cap_dataInicio.ToShortDateString(), cap_dataFim.ToShortDateString())); } } #endregion var dao = new CLS_TurmaAulaGeradaDAO(); foreach (var tud_id in tagsSalvar.Select(tag => tag.tud_id).Distinct()) { var banco = dao._Banco.CopyThisInstance(); try { banco.Open(IsolationLevel.ReadCommitted); #region Busca dados iniciais do tud. var tagsByTud = tagsSalvar.Where(t => t.tud_id == tud_id).ToList(); var tud_tipo = tagsByTud.First().tud_tipo; var fav_tipoApuracaoFrequencia = tagsByTud.First().fav_tipoApuracaoFrequencia; var ttn_tipo = tagsByTud.First().ttn_tipo; if (((tud_tipo == (byte)TurmaDisciplinaTipo.Regencia && fav_tipoApuracaoFrequencia != (byte)ACA_FormatoAvaliacaoTipoApuracaoFrequencia.TemposAula) || (tud_tipo == (byte)TurmaDisciplinaTipo.DisciplinaPrincipal && ttn_tipo != (byte)ACA_TipoTurnoBO.TipoTurno.Integral)) && tagsByTud.Any(tag => tag.tag_numeroAulas > 1)) { throw new ValidationException(string.Format("A carga horária diária do componente {0} não deve ser maior que 1.", dicTurmasDisciplinas[tud_id])); } if (tud_tipo == (byte)TurmaDisciplinaTipo.DisciplinaPrincipal && ttn_tipo == (byte)ACA_TipoTurnoBO.TipoTurno.Integral && tagsByTud.Any(tag => tag.tag_numeroAulas > 2)) { throw new ValidationException(string.Format("A carga horária diária do componente {0} não deve ser maior que 2.", dicTurmasDisciplinas[tud_id])); } tud_cargaHorariaSemanal = tagsByTud.First().tud_cargaHorariaSemanal; var cal = dicPeriodosCalendario.First(i => i.Key == tagsByTud.First().cal_id).Value; var inicio = dataInicial.GetValueOrDefault(Convert.ToDateTime(cal.Rows[0]["cap_dataInicio"])); var fim = dataFinal.GetValueOrDefault(Convert.ToDateTime(cal.Rows[0]["cap_dataFim"])); var cap_dataInicio = dataInicial.GetValueOrDefault(Convert.ToDateTime(cal.Rows[0]["cap_dataInicio"])); var cap_dataFim = dataFinal.GetValueOrDefault(Convert.ToDateTime(cal.Rows[0]["cap_dataFim"])); string tud_ids = tud_id.ToString(); List <TUR_TurmaDisciplinaTerritorio> territorios = null; if (tagsByTud.First().tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia) { territorios = TUR_TurmaDisciplinaTerritorioBO.SelecionaVigentesPorExperienciaPeriodo(tud_id, inicio, fim); tud_ids = territorios.Aggregate(tud_ids, (a, i) => string.Format("{0};{1}", a, i.tud_idTerritorio)); // Quantidade de aulas máxima da experiência: quantidade de territórios ligados à ela. tud_cargaHorariaSemanal = territorios.Count; //if (tagsByTud.Sum(p => p.tag_numeroAulas) > tud_cargaHorariaSemanal) //{ // throw new ValidationException(string.Format("A carga horária semanal do componente {0} não deve ser maior que {1}." // , dicTurmasDisciplinas[tud_id], tud_cargaHorariaSemanal)); //} } // Recupera as CLS_TurmaAula que já existem no banco para o docente na turma e período informado // Territórios do saber: se tud_id for relativo a uma experiência, buscará as aulas também dos territórios var aulasBanco = CLS_TurmaAulaBO.SelecionaAulasAtividadesPor_DisicplinasDocentePeriodo(tud_ids, tpc_id, doc_id, banco).Rows.OfType <DataRow>().ToList(); // Recupera as disciplinas compartilhadas vigentes para o docente na turma var lstDisciplinaCompartilhada = TUR_TurmaDisciplinaBO.SelectRelacionadaVigenteBy_DisciplinaCompartilhada(tud_id, 0, false, doc_id, banco); var diasNaoUteis = dicDiasNaoUteis.First(i => i.Key == tagsByTud.First().esc_id).Value; var aulasSalvar = new Dictionary <long[], CLS_TurmaAula>(); var aulasExcluir = new List <CLS_TurmaAula>(); // esta lista totalizará as aulas que *permanecerão* na semana // (considerando também as que permanecerão inalteradas no banco) // após as gravações das listas aulasSalvar e aulasExcluir var aulasSemana = new List <CLS_TurmaAula>(); // variáveis usadas na geração de msgs de erro de vigência dos territórios do saber bool temTerritorioVigente = true; bool temTerritorioVigenteDiaAnterior = true; DateTime vigenciaInicio = inicio; DateTime vigenciaFim = inicio; #endregion while (inicio <= fim) { foreach (var tag in tagsByTud.Where(t => inicio.DayOfWeek == RetornaDiaSemana(t.tag_diaSemana))) { #region Percorre os dias da semana configurado com aula na agenda if (!diasNaoUteis.Any(d => d.Date == inicio.Date)) { #region Territórios do Saber - Recupera dados para verificações //guarda os territórios que efetivamente estão vigentes para a experiência na data em questão var territoriosVigentes = (territorios == null) ? null : territorios.Where(t => t.tte_vigenciaInicio.Date <= inicio.Date && (t.tte_vigenciaFim == new DateTime() || t.tte_vigenciaFim.Date >= inicio.Date)).ToList(); //guarda as aulas que já estão criadas no banco para os territórios vigentes na data em questão var aulasTerritoriosBanco = (territorios == null) ? null : aulasBanco.Where(dr => territoriosVigentes.Select(t => t.tud_idTerritorio).Contains(Convert.ToInt64(dr["tud_id"])) && Convert.ToInt16(dr["tdt_posicao"]) == tag.tdt_posicao && Convert.ToDateTime(dr["tau_data"]) == inicio) .Select(dr => new { PermiteAlterar = Convert.ToBoolean(dr["PermiteAlterar"]), Aula = new CLS_TurmaAulaDAO().DataRowToEntity(dr, new CLS_TurmaAula()) }) .ToList(); #endregion #region Recupera aulas existentes no banco de dados var aulaBanco = aulasBanco .Where(dr => Convert.ToInt64(dr["tud_id"]) == tag.tud_id && Convert.ToInt16(dr["tdt_posicao"]) == tag.tdt_posicao && Convert.ToDateTime(dr["tau_data"]) == inicio && (tag.tud_idRelacionada <= 0 || Convert.ToInt64(dr["tud_idRelacionada"]) == tag.tud_idRelacionada)) .Select(dr => new { /* Territórios do saber: * só poderá editar a aula da experiência se ela E as aulas * correspondentes de TODOS os territórios vigentes na data * da aula puderem ser editadas também */ PermiteAlterar = Convert.ToBoolean(dr["PermiteAlterar"]) && (territorios == null || !aulasTerritoriosBanco.Any(a => !a.PermiteAlterar)), Aula = new CLS_TurmaAulaDAO().DataRowToEntity(dr, new CLS_TurmaAula()) }) .FirstOrDefault(); #endregion temTerritorioVigente = (territorios == null || territoriosVigentes.Count > 0); if (tag.tag_numeroAulas > 0) { // Há aulas previstas para esse dia da semana if (aulaBanco == null) { #region Cria aula if (temTerritorioVigente) { var nova = new CLS_TurmaAula { tud_id = tag.tud_id, tau_id = -1, tur_id = tag.tur_id, tpc_id = tpc_id, tau_data = inicio, tau_sequencia = -1, tau_numeroAulas = tag.tag_numeroAulas, tau_situacao = 1, tdt_posicao = Convert.ToByte(tag.tdt_posicao > 0 ? tag.tdt_posicao : 1), usu_id = usu_id, IsNew = true, tud_tipo = tag.tud_tipo }; aulasSalvar.Add(new long[] { tag.tud_id, tag.tud_idRelacionada }, nova); aulasSemana.Add(nova); } #endregion } else { if (aulaBanco.PermiteAlterar) { #region Altera aula existente if (temTerritorioVigente) { aulaBanco.Aula.tau_numeroAulas = tag.tag_numeroAulas; aulaBanco.Aula.tau_sequencia = -1; aulaBanco.Aula.tur_id = tag.tur_id; aulaBanco.Aula.IsNew = false; aulaBanco.Aula.tud_tipo = tag.tud_tipo; aulasSalvar.Add(new long[] { tag.tud_id, tag.tud_idRelacionada }, aulaBanco.Aula); } #endregion } else { gerouTodasAulas = false; } aulasSemana.Add(aulaBanco.Aula); } } // Não há aulas previstas para esse dia da semana // Exclui as aulas que já estão no calendário (quando possível) else if (aulaBanco != null) { if (aulaBanco.PermiteAlterar) { if (territorios == null || territoriosVigentes.Count > 0) { aulaBanco.Aula.tur_id = tag.tur_id; aulasExcluir.Add(aulaBanco.Aula); } else { // Se não vai excluir a aula, coloca na lista da semana para contabilizar quantidade de aulas. aulasSemana.Add(aulaBanco.Aula); } } else { gerouTodasAulas = false; // Se não vai excluir a aula, coloca na lista da semana para contabilizar quantidade de aulas. aulasSemana.Add(aulaBanco.Aula); } } #region Territorios do saber - msg de vigência if (temTerritorioVigente && !temTerritorioVigenteDiaAnterior) { string inicioFimTxt = ""; if (territorios != null && (territorios.Any(t => t.tte_vigenciaInicio.Date <= vigenciaInicio.Date) || territorios.Any(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date))) { if (!territorios.Any(t => t.tte_vigenciaInicio.Date <= vigenciaInicio.Date)) { inicioFimTxt = vigenciaInicio.ToString("dd/MM/yyyy") + " - " + territorios.Where(t => t.tte_vigenciaInicio.Date > vigenciaInicio.Date) .OrderBy(t => t.tte_vigenciaInicio).First() .tte_vigenciaInicio.ToString("dd/MM/yyyy"); } if (territorios.Any(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date)) { foreach (TUR_TurmaDisciplinaTerritorio tte in territorios.Where(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date) .OrderBy(t => t.tte_vigenciaInicio)) { inicioFimTxt += string.IsNullOrEmpty(inicioFimTxt) ? "" : " e "; if (tte.tte_vigenciaFim.Date < vigenciaFim.Date) { inicioFimTxt += tte.tte_vigenciaFim.AddDays(1).ToString("dd/MM/yyyy") + " - " + (territorios.Any(t => t.tte_vigenciaInicio > tte.tte_vigenciaFim.Date) ? territorios.Where(t => t.tte_vigenciaInicio > tte.tte_vigenciaFim.Date) .OrderBy(t => t.tte_vigenciaInicio).First() .tte_vigenciaInicio.AddDays(-1).ToString("dd/MM/yyyy") : vigenciaFim.ToString("dd/MM/yyyy")); } } } } else { inicioFimTxt = vigenciaInicio.ToString("dd/MM/yyyy") + " - " + vigenciaFim.ToString("dd/MM/yyyy"); } // mostra msg if (semVigencia.ContainsKey(tud_id)) { semVigencia[tud_id] = String.Format("{0}, {1}", semVigencia[tud_id], inicioFimTxt); } else { semVigencia.Add(tud_id, String.Format("{0}: {1}", dicTurmasDisciplinas[tud_id], inicioFimTxt)); } } if (temTerritorioVigente != temTerritorioVigenteDiaAnterior) { // reinicia contagem vigenciaInicio = inicio; } temTerritorioVigenteDiaAnterior = temTerritorioVigente; vigenciaFim = inicio; #endregion } #endregion } // Ao final da semana ou do intervalo informado if (inicio.DayOfWeek == DayOfWeek.Sunday || inicio == fim) { #region Grava os dados da semana DateTime dataIniSemana; DateTime dataFimSemana; #region Calcula datas de início e final da semana em questão if (inicio.DayOfWeek == DayOfWeek.Sunday) { dataIniSemana = inicio.AddDays(-7); dataFimSemana = inicio.AddDays(-1); } else { dataIniSemana = inicio.AddDays((int)inicio.DayOfWeek * (-1)); dataFimSemana = fim.AddDays(((int)fim.DayOfWeek - (int)DayOfWeek.Saturday) * (-1)); } #endregion int quantidadeAulasDaSemana = aulasSalvar.Sum(p => p.Value.tau_numeroAulas); if (dataIniSemana.Date < cap_dataInicio.Date) { // Somar com as aulas que estiverem cadastradas fora do tpc_id. quantidadeAulasDaSemana += CLS_TurmaAulaBO.VerificaSomaNumeroAulasSemana (tud_id, dataIniSemana, cap_dataInicio.Date.AddDays(-1), banco, Convert.ToByte(tagsByTud.FirstOrDefault().tdt_posicao)); } if (dataFimSemana.Date > cap_dataFim.Date) { // Somar com as aulas que estiverem cadastradas fora do tpc_id. quantidadeAulasDaSemana += CLS_TurmaAulaBO.VerificaSomaNumeroAulasSemana (tud_id, cap_dataFim.Date.AddDays(1), dataFimSemana, banco, Convert.ToByte(tagsByTud.FirstOrDefault().tdt_posicao)); } if ((aulasSalvar.Any() || aulasExcluir.Any()) && DateTime.Today >= dataLimiteLancamento && tud_tipo != (byte)ACA_CurriculoDisciplinaTipo.DocenciaCompartilhada && tud_tipo != (byte)ACA_CurriculoDisciplinaTipo.Experiencia && !semAulasPrevistas.ContainsKey(tud_id) && !TUR_TurmaDisciplinaAulaPrevistaBO.VerificaLancamento(tud_id, doc_id, tagsByTud.First().tur_id, tagsByTud.First().cal_id)) { semAulasPrevistas.Add(tud_id, dicTurmasDisciplinas[tud_id]); } // Se extrapolou a qtde de horas na semana... else if (quantidadeAulasDaSemana > tud_cargaHorariaSemanal) { // ... e há itens nas listas para gravar... if (aulasSalvar.Any() || aulasExcluir.Any()) { // ... gera mensagem de alerta ao usuário if (ultrapassouCargaHorariaSemanal.ContainsKey(tud_id)) { ultrapassouCargaHorariaSemanal[tud_id] = String.Format("{0}, {1} - {2}", ultrapassouCargaHorariaSemanal[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy")); } else { ultrapassouCargaHorariaSemanal.Add(tud_id, String.Format("{0}: {1} - {2}", dicTurmasDisciplinas[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy"))); } } } else { bool gravouTodasTurmaAula = gerouTodasAulas; bool ultrapassouTerritorios = false; if (aulasExcluir.Any()) { aulasExcluir.ForEach(tau => gravouTodasTurmaAula &= CLS_TurmaAulaBO.Delete(tau, banco, origemLogAula, (byte)LOG_TurmaAula_Alteracao_Tipo.ExclusaoAula, usu_id)); } if (aulasSalvar.Any()) { // Ligação da experiência com territórios nas aulas da semana. List <TurmaAulaTerritorioDados> aulasTerritorios = new List <TurmaAulaTerritorioDados>(); Dictionary <long, int> dicTerritorios = new Dictionary <long, int>(); if (tagsByTud.FirstOrDefault().tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia && territorios != null && territorios.Count > 0) { // Territórios vigentes dentro da semana. var territoriosVigentes = territorios.Where (t => t.tte_vigenciaInicio.Date <= dataFimSemana.Date && (t.tte_vigenciaFim == new DateTime() || t.tte_vigenciaFim.Date >= dataIniSemana.Date)).ToList(); if (aulasSalvar.Any(tau => tau.Value.tau_numeroAulas > territoriosVigentes.Count)) { ultrapassouTerritorios = true; if (ultrapassouCargaHorariaSemanal.ContainsKey(tud_id)) { ultrapassouCargaHorariaSemanal[tud_id] = String.Format("{0}, {1} - {2}", ultrapassouCargaHorariaSemanal[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy")); } else { ultrapassouCargaHorariaSemanal.Add(tud_id, String.Format("{0}: {1} - {2}", dicTurmasDisciplinas[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy"))); } } } if (!ultrapassouTerritorios) { ultrapassouCargaHorariaSemanalTerritorio = ultrapassouCargaHorariaSemanal; aulasSalvar.ToList() .ForEach(tau => { gravouTodasTurmaAula &= /*(tau.Value.tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia ? CLS_TurmaAulaBO.SalvarAulaTerritorio(tau.Value, banco): */ tau.Key[1] > 0 ? CLS_TurmaAulaBO.Save(tau.Value, banco, lstDisciplinaCompartilhada.First(tdr => tdr.tud_id == tau.Key[1]), origemLogAula, (byte)LOG_TurmaAula_Alteracao_Tipo.AlteracaoAula, usu_id) : CLS_TurmaAulaBO.Save(tau.Value, banco, origemLogAula, (byte)LOG_TurmaAula_Alteracao_Tipo.AlteracaoAula, usu_id); if (tagsByTud.FirstOrDefault().tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia && territorios != null && territorios.Count > 0) { // Territórios vigentes dentro da semana. var territoriosVigentes = territorios.Where (t => t.tte_vigenciaInicio.Date <= dataFimSemana.Date && (t.tte_vigenciaFim == new DateTime() || t.tte_vigenciaFim.Date >= dataIniSemana.Date)).ToList(); // Ligação da experiência com territórios nas aulas da semana. aulasTerritorios = CLS_TurmaAulaTerritorioBO.SelecionaAulasTerritorioPorExperiencia (tud_id, dataIniSemana, dataFimSemana, banco); dicTerritorios = (from TUR_TurmaDisciplinaTerritorio item in territoriosVigentes.Where(t => !aulasTerritorios.Any(a => a.tud_idTerritorio == t.tud_idTerritorio && a.tau_idExperiencia != tau.Value.tau_id)) select new { tud_id = item.tud_idTerritorio , tud_nomeTerritorio = item.tud_nomeTerritorio , qtAulas = (from TurmaAulaTerritorioDados iAula in aulasTerritorios where iAula.tud_idExperiencia == item.tud_idExperiencia && iAula.tud_idTerritorio == item.tud_idTerritorio select iAula.tud_idTerritorio).Count() }).OrderBy(p => p.tud_nomeTerritorio).ToDictionary(p => p.tud_id, p => p.qtAulas); //Se for uma edição de aula então pega apenas as aulas ligadas à ela aulasTerritorios = aulasTerritorios.Where(a => a.tud_idExperiencia == tau.Value.tud_id && a.tau_idExperiencia == tau.Value.tau_id).ToList(); //Valida a carga horária da experiência if (!dicTerritorios.Any() && !aulasTerritorios.Any()) { gravouTodasTurmaAula &= false; // ... gera mensagem de alerta ao usuário if (ultrapassouCargaHorariaSemanalTerritorio.ContainsKey(tud_id)) { ultrapassouCargaHorariaSemanalTerritorio[tud_id] = String.Format("{0}, {1} - {2}", ultrapassouCargaHorariaSemanalTerritorio[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy")); } else { ultrapassouCargaHorariaSemanalTerritorio.Add(tud_id, String.Format("{0}: {1} - {2}", dicTurmasDisciplinas[tud_id], dataIniSemana.ToString("dd/MM/yyyy"), dataFimSemana.ToString("dd/MM/yyyy"))); } } else { // Verifica ligações com territórios quando a aula é de experiência. CLS_TurmaAulaBO.CriaLigacoesTerritorios(usu_id, origemLogAula, tau.Value, banco, aulasTerritorios, dicTerritorios); } } }); ultrapassouCargaHorariaSemanal = ultrapassouCargaHorariaSemanalTerritorio; } } gerouTodasAulas &= gravouTodasTurmaAula; } aulasSalvar.Clear(); aulasExcluir.Clear(); aulasSemana.Clear(); #endregion } inicio = inicio.AddDays(1); } #region Territorios do saber - msg de vigência if (!temTerritorioVigente) { string inicioFimTxt = ""; if (territorios != null && (territorios.Any(t => t.tte_vigenciaInicio.Date <= vigenciaInicio.Date) || territorios.Any(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date))) { if (!territorios.Any(t => t.tte_vigenciaInicio.Date <= vigenciaInicio.Date)) { inicioFimTxt = vigenciaInicio.ToString("dd/MM/yyyy") + " - " + territorios.Where(t => t.tte_vigenciaInicio.Date > vigenciaInicio.Date) .OrderBy(t => t.tte_vigenciaInicio).First() .tte_vigenciaInicio.ToString("dd/MM/yyyy"); } if (territorios.Any(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date)) { foreach (TUR_TurmaDisciplinaTerritorio tte in territorios.Where(t => t.tte_vigenciaFim != new DateTime() && t.tte_vigenciaFim.Date < vigenciaFim.Date) .OrderBy(t => t.tte_vigenciaInicio)) { inicioFimTxt += string.IsNullOrEmpty(inicioFimTxt) ? "" : " e "; if (tte.tte_vigenciaFim.Date < vigenciaFim.Date) { inicioFimTxt += tte.tte_vigenciaFim.AddDays(1).ToString("dd/MM/yyyy") + " - " + (territorios.Any(t => t.tte_vigenciaInicio > tte.tte_vigenciaFim.Date) ? territorios.Where(t => t.tte_vigenciaInicio > tte.tte_vigenciaFim.Date) .OrderBy(t => t.tte_vigenciaInicio).First() .tte_vigenciaInicio.AddDays(-1).ToString("dd/MM/yyyy") : vigenciaFim.ToString("dd/MM/yyyy")); } } } } else { inicioFimTxt = vigenciaInicio.ToString("dd/MM/yyyy") + " - " + vigenciaFim.ToString("dd/MM/yyyy"); } // Entra aqui somente qdo não há vigência na última data com aula para gerar if (semVigencia.ContainsKey(tud_id)) { semVigencia[tud_id] = String.Format("{0}, {1}", semVigencia[tud_id], inicioFimTxt); } else { semVigencia.Add(tud_id, String.Format("{0}: {1}", dicTurmasDisciplinas[tud_id], inicioFimTxt)); } } #endregion bool gravouTodas = gerouTodasAulas; tagsByTud.ForEach(tag => gravouTodas &= Save(tag, banco)); gerouTodasAulas &= gravouTodas; CLS_TurmaAulaBO.AtualizarSequenciaAulasPorTurmaDisciplina(tud_id, banco); // Caso o fechamento seja automático, grava na fila de processamento. if (tagsByTud.First().fav_fechamentoAutomatico&& tagsByTud.First().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); } } catch (Exception ex) { outrosErros.Add(tud_id, ex); banco.Close(ex); } finally { if (banco.ConnectionIsOpen) { banco.Close(); } } } return(true); }
/// <summary> /// O método salva as observações para conselho pedagógico. /// </summary> /// <param name="tur_id">ID da turma.</param> /// <param name="alu_id">ID do aluno.</param> /// <param name="mtu_id">ID da matrícula turma do aluno.</param> /// <param name="fav_id">ID do formato de avaliação.</param> /// <param name="ava_id">ID da avaliação.</param> /// <param name="ltObservacao">Lista de observações.</param> /// <param name="banco">Banco</param> /// <param name="ent_id">Id da entidade do usuário logado.</param> /// <returns></returns> public static bool SalvarObservacao ( long tur_id, long alu_id, int mtu_id, int fav_id, int ava_id, CLS_AlunoAvaliacaoTur_Observacao observacao, Guid usu_idLogado, byte resultado, string justificativaResultado, DateTime dataUltimaAlteracaoObservacao, DateTime dataUltimaAlteracaoNotaFinal, ACA_FormatoAvaliacao entFormatoAvaliacao, List <CLS_AvaliacaoTurDisc_Cadastro> listaDisciplina, List <MTR_MatriculaTurmaDisciplina> listaMatriculaTurmaDisciplina, int tamanhoMaximoKB, string[] TiposArquivosPermitidos, ref List <CLS_AlunoAvaliacaoTurmaDisciplina> listaAtualizacaoEfetivacao, Guid ent_id, int tpc_id ) { TalkDBTransaction banco = new CLS_AlunoAvaliacaoTurmaObservacaoDAO()._Banco.CopyThisInstance(); banco.Open(IsolationLevel.ReadCommitted); List <AlunoFechamentoPendencia> FilaProcessamento = new List <AlunoFechamentoPendencia>(); try { if (observacao.entityObservacao != null && observacao.entityObservacao != new CLS_AlunoAvaliacaoTurmaObservacao()) { Save(observacao.entityObservacao, banco); } int tpc_idUtilizado = -1; List <CLS_AvaliacaoTurDisc_Cadastro> listaDisciplinasUltimoPeriodo = new List <CLS_AvaliacaoTurDisc_Cadastro>(); listaDisciplinasUltimoPeriodo = listaDisciplina.Where(d => d.entity.ava_id != ava_id).ToList(); if (listaDisciplinasUltimoPeriodo.Count > 0) { tpc_idUtilizado = ACA_AvaliacaoBO.SelecionaMaiorBimestre_ByFormatoAvaliacao(entFormatoAvaliacao.fav_id, banco); } CLS_AlunoAvaliacaoTurmaDisciplinaBO.SaveAvaliacaoFinal( tur_id , entFormatoAvaliacao , listaDisciplina , tamanhoMaximoKB , TiposArquivosPermitidos , dataUltimaAlteracaoNotaFinal , listaMatriculaTurmaDisciplina , ref listaAtualizacaoEfetivacao , banco); tpc_idUtilizado = tpc_idUtilizado > 0 ? tpc_idUtilizado : tpc_id; if (entFormatoAvaliacao.fav_fechamentoAutomatico && listaMatriculaTurmaDisciplina.Any()) { FilaProcessamento.AddRange(listaMatriculaTurmaDisciplina .Select(p => new AlunoFechamentoPendencia { tud_id = p.tud_id, tpc_id = tpc_idUtilizado, afp_frequencia = true, afp_nota = true, afp_processado = (Byte)(p.mtd_id <= 0 ? 0 : 2) }).ToList()); } // Se for passado o resultado, salva na MTR_MatriculaTurma. if (!usu_idLogado.Equals(Guid.Empty)) { MTR_MatriculaTurma entMatr = new MTR_MatriculaTurma { alu_id = alu_id , mtu_id = mtu_id }; MTR_MatriculaTurmaBO.GetEntity(entMatr, banco); // Se o registro foi alterado depois da data da alteração mais recente no momento em que os dados foram carregados, // interrompe o salvamento e alerta o usuário de que é necessário atualizar os dados if (entMatr != null && !entMatr.IsNew && Convert.ToDateTime(entMatr.mtu_dataAlteracao.ToString()) > dataUltimaAlteracaoObservacao) { throw new ValidationException("Existe registro alterado mais recentemente, é necessário atualizar os dados."); } else { entMatr.usu_idResultado = usu_idLogado; entMatr.mtu_resultado = resultado; entMatr.mtu_relatorio = justificativaResultado; MTR_MatriculaTurmaBO.Save(entMatr, banco); if (ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.GERAR_HISTORICO_SALVAR_PARECER_CONCLUSIVO, ent_id)) { ACA_AlunoHistoricoBO.GeracaoHistoricoPedagogicoPorAluno(entMatr.alu_id, entMatr.mtu_id, banco); } if (entFormatoAvaliacao.fav_fechamentoAutomatico) { FilaProcessamento.Add(new AlunoFechamentoPendencia { tud_id = listaMatriculaTurmaDisciplina.FirstOrDefault().tud_id, tpc_id = tpc_id, afp_frequencia = true, afp_nota = true, afp_processado = (Byte)(entMatr.IsNew == true ? 0 : 2) }); } } } // Limpa cache do fechamento, para atualizar o check. GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaBO.RetornaChaveCache_GetSelectBy_Turma_Periodo(tur_id, fav_id, ava_id)); List <TUR_TurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, null, GestaoEscolarUtilBO.MinutosCacheLongo); listaDisciplinas.ForEach(p => { GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodo(p.tud_id, fav_id, ava_id, string.Empty)); GestaoEscolarUtilBO.LimpaCache(MTR_MatriculaTurmaDisciplinaBO.RetornaChaveCache_GetSelectBy_TurmaDisciplinaPeriodoFiltroDeficiencia(p.tud_id, fav_id, ava_id, string.Empty)); // Chaves do fechamento automatico string chave = string.Empty; chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_MODEL_KEY, p.tud_id, tpc_id); CacheManager.Factory.RemoveByPattern(chave); chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id, tpc_id); CacheManager.Factory.RemoveByPattern(chave); chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_MODEL_KEY, p.tud_id); CacheManager.Factory.RemoveByPattern(chave); chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_FILTRO_DEFICIENCIA_MODEL_KEY, p.tud_id); CacheManager.Factory.RemoveByPattern(chave); chave = String.Format(ModelCache.FECHAMENTO_AUTO_BIMESTRE_COMPONENTES_REGENCIA_MODEL_KEY, tur_id, tpc_id); CacheManager.Factory.RemoveByPattern(chave); chave = String.Format(ModelCache.FECHAMENTO_AUTO_FINAL_COMPONENTES_REGENCIA_MODEL_KEY, tur_id, tpc_id); CacheManager.Factory.RemoveByPattern(chave); // }); if (entFormatoAvaliacao.fav_fechamentoAutomatico && FilaProcessamento.Any(a => a.tpc_id > 0)) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias( FilaProcessamento .GroupBy(g => new { g.tud_id, g.tpc_id }) .Select(p => new AlunoFechamentoPendencia { tud_id = p.FirstOrDefault().tud_id, tpc_id = p.FirstOrDefault().tpc_id, afp_frequencia = p.FirstOrDefault().afp_frequencia, afp_nota = p.FirstOrDefault().afp_nota, afp_processado = FilaProcessamento .Where(w => w.tud_id == p.FirstOrDefault().tud_id&& w.tpc_id == p.FirstOrDefault().tpc_id) .Min(m => m.afp_processado) }) .Where(w => w.tpc_id > 0 && w.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id)) .ToList() , banco); } return(true); } catch (ValidationException ex) { banco.Close(ex); throw; } catch (Exception ex) { banco.Close(ex); throw; } finally { if (banco.ConnectionIsOpen) { banco.Close(); } } }
public static bool Salvar(RelatorioPreenchimentoAluno relatorio, List <CLS_AlunoDeficienciaDetalhe> lstDeficienciaDetalhe, bool permiteAlterarRacaCor, byte racaCor, List <CLS_RelatorioPreenchimentoAcoesRealizadas> lstAcoesRealizadas) { CLS_RelatorioPreenchimentoDAO dao = new CLS_RelatorioPreenchimentoDAO(); dao._Banco.Open(IsolationLevel.ReadCommitted); PES_PessoaDAO daoCore = new PES_PessoaDAO(); daoCore._Banco.Open(IsolationLevel.ReadCommitted); try { bool retorno = true; if (permiteAlterarRacaCor) { ACA_Aluno alu = new ACA_Aluno { alu_id = relatorio.entityPreenchimentoAlunoTurmaDisciplina.alu_id }; ACA_AlunoBO.GetEntity(alu); PES_Pessoa pes = new PES_Pessoa { pes_id = alu.pes_id }; PES_PessoaBO.GetEntity(pes); pes.pes_racaCor = racaCor; PES_PessoaBO.Save(pes, daoCore._Banco); } List <CLS_AlunoDeficienciaDetalhe> lstDeficienciaDetalheBanco = (from sAlunoDeficiencia alunoDeficiencia in CLS_AlunoDeficienciaDetalheBO.SelecionaPorAluno(relatorio.entityPreenchimentoAlunoTurmaDisciplina.alu_id) from sAlunoDeficienciaDetalhe alunoDeficienciaDetalhe in alunoDeficiencia.lstDeficienciaDetalhe select new CLS_AlunoDeficienciaDetalhe { alu_id = relatorio.entityPreenchimentoAlunoTurmaDisciplina.alu_id , tde_id = alunoDeficiencia.tde_id , dfd_id = alunoDeficienciaDetalhe.dfd_id }).ToList(); if (lstDeficienciaDetalheBanco.Any()) { lstDeficienciaDetalheBanco.ForEach(p => CLS_AlunoDeficienciaDetalheBO.Delete(p, dao._Banco)); } if (relatorio.entityRelatorioPreenchimento.reap_id > 0) { CLS_QuestionarioConteudoPreenchimentoBO.ExcluiPorReapId(relatorio.entityRelatorioPreenchimento.reap_id, dao._Banco); CLS_QuestionarioRespostaPreenchimentoBO.ExcluiPorReapId(relatorio.entityRelatorioPreenchimento.reap_id, dao._Banco); } retorno &= Save(relatorio.entityRelatorioPreenchimento, dao._Banco); relatorio.entityPreenchimentoAlunoTurmaDisciplina.reap_id = relatorio.entityRelatorioPreenchimento.reap_id; retorno &= CLS_RelatorioPreenchimentoAlunoTurmaDisciplinaBO.Save(relatorio.entityPreenchimentoAlunoTurmaDisciplina, dao._Banco); relatorio.lstQuestionarioConteudoPreenchimento.ForEach ( p => { p.reap_id = relatorio.entityRelatorioPreenchimento.reap_id; retorno &= CLS_QuestionarioConteudoPreenchimentoBO.Save(p, dao._Banco); } ); relatorio.lstQuestionarioRespostaPreenchimento.ForEach ( p => { p.reap_id = relatorio.entityRelatorioPreenchimento.reap_id; retorno &= CLS_QuestionarioRespostaPreenchimentoBO.Save(p, dao._Banco); } ); lstDeficienciaDetalhe.ForEach ( p => { retorno &= CLS_AlunoDeficienciaDetalheBO.Save(p, dao._Banco); } ); lstAcoesRealizadas.ForEach ( p => { if (p.rpa_situacao == (byte)CLS_RelatorioPreenchimentoAcoesRealizadasSituacao.Excluido) { retorno &= CLS_RelatorioPreenchimentoAcoesRealizadasBO.Delete(p, dao._Banco); } else { p.reap_id = relatorio.entityRelatorioPreenchimento.reap_id; retorno &= CLS_RelatorioPreenchimentoAcoesRealizadasBO.Save(p, dao._Banco); } } ); CLS_RelatorioAtendimento relatorioAtendimento = CLS_RelatorioAtendimentoBO.GetEntity(new CLS_RelatorioAtendimento { rea_id = relatorio.entityRelatorioPreenchimento.rea_id }); ACA_CalendarioAnual calendario = ACA_CalendarioAnualBO.SelecionaPorTurma(relatorio.entityPreenchimentoAlunoTurmaDisciplina.tur_id); List <MTR_MatriculaTurma> matriculasAno = MTR_MatriculaTurmaBO.GetSelectMatriculasAlunoAno(relatorio.entityPreenchimentoAlunoTurmaDisciplina.alu_id, calendario.cal_ano); matriculasAno.ForEach(p => CLS_RelatorioPreenchimentoAlunoTurmaDisciplinaBO.LimpaCache_AlunoPreenchimentoPorPeriodoDisciplina(relatorio.entityPreenchimentoAlunoTurmaDisciplina.tpc_id, p.tur_id)); if (relatorioAtendimento.rea_gerarPendenciaFechamento && ACA_FormatoAvaliacaoBO.CarregarPorTur(relatorio.entityPreenchimentoAlunoTurmaDisciplina.tur_id, dao._Banco).fav_fechamentoAutomatico) { List <AlunoFechamentoPendencia> FilaProcessamento = new List <AlunoFechamentoPendencia>(); if (relatorioAtendimento.rea_tipo == (byte)CLS_RelatorioAtendimentoTipo.RP && relatorio.entityPreenchimentoAlunoTurmaDisciplina.tud_id > 0) { if (relatorio.entityPreenchimentoAlunoTurmaDisciplina.tpc_id > 0) { FilaProcessamento.Add( new AlunoFechamentoPendencia { tud_id = relatorio.entityPreenchimentoAlunoTurmaDisciplina.tud_id , tpc_id = relatorio.entityPreenchimentoAlunoTurmaDisciplina.tpc_id , afp_frequencia = true , afp_nota = true , afp_processado = 2 }); } else { FilaProcessamento.AddRange(ACA_CalendarioPeriodoBO.SelecionaPor_Calendario(calendario.cal_id, GestaoEscolarUtilBO.MinutosCacheLongo) .Select(p => new AlunoFechamentoPendencia { tud_id = relatorio.entityPreenchimentoAlunoTurmaDisciplina.tud_id, tpc_id = p.tpc_id, afp_frequencia = true, afp_nota = false, afp_processado = 2 }).ToList()); } } else { if (relatorio.entityPreenchimentoAlunoTurmaDisciplina.tpc_id > 0) { FilaProcessamento.AddRange(TUR_TurmaDisciplinaBO.GetSelectBy_Turma(relatorio.entityPreenchimentoAlunoTurmaDisciplina.tur_id, dao._Banco, GestaoEscolarUtilBO.MinutosCacheLongo) .Select(p => new AlunoFechamentoPendencia { tud_id = p.tud_id , tpc_id = relatorio.entityPreenchimentoAlunoTurmaDisciplina.tpc_id , afp_frequencia = true , afp_nota = true , afp_processado = 2 }).ToList()); } else { var periodos = ACA_CalendarioPeriodoBO.SelecionaPor_Calendario(calendario.cal_id, GestaoEscolarUtilBO.MinutosCacheLongo); FilaProcessamento.AddRange(TUR_TurmaDisciplinaBO.GetSelectBy_Turma(relatorio.entityPreenchimentoAlunoTurmaDisciplina.tur_id, dao._Banco, GestaoEscolarUtilBO.MinutosCacheLongo) .SelectMany ( tud => periodos.Select ( tpc => new AlunoFechamentoPendencia { tud_id = tud.tud_id , tpc_id = tpc.tpc_id , afp_frequencia = true , afp_nota = true , afp_processado = 2 } ).ToList() )); } } if (FilaProcessamento.Any()) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(FilaProcessamento, dao._Banco); } } return(retorno); } catch (Exception ex) { dao._Banco.Close(ex); daoCore._Banco.Close(ex); throw; } finally { if (dao._Banco.ConnectionIsOpen) { dao._Banco.Close(); } if (daoCore._Banco.ConnectionIsOpen) { daoCore._Banco.Close(); } } }
/// <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> /// Realiza as validações necessárias e salva a atividade extraclasse. /// </summary> /// <param name="entity"></param> /// <returns></returns> public static bool Salvar(CLS_TurmaAtividadeExtraClasse entity, int cal_id, bool fechamentoAutomatico, Guid ent_id, List <long> lstDisciplinas, Guid usu_id, long tur_id) { TalkDBTransaction banco = new CLS_TurmaAtividadeExtraClasseDAO()._Banco.CopyThisInstance(); banco.Open(IsolationLevel.ReadCommitted); try { List <CLS_TurmaAtividadeExtraClasse> lstEntities = new List <CLS_TurmaAtividadeExtraClasse>(); bool isNew = entity.IsNew; if (lstDisciplinas.Count > 0) { if (isNew) { CLS_TurmaAtividadeExtraClasseRelacionada relacionada = new CLS_TurmaAtividadeExtraClasseRelacionada(); relacionada.IsNew = true; relacionada.usu_id = usu_id; if (CLS_TurmaAtividadeExtraClasseRelacionadaBO.Save(relacionada, banco)) { entity.taer_id = relacionada.taer_id; lstDisciplinas.ForEach(p => { if (p != entity.tud_id) { lstEntities.Add(new CLS_TurmaAtividadeExtraClasse { tud_id = p, tae_id = -1, taer_id = entity.taer_id, IsNew = true }); } }); } else { throw new Exception("Erro ao tentar salvar componente curricular relacionado."); } } else { List <CLS_TurmaAtividadeExtraClasse> lstRelacionadas = SelecionaAtividadeExtraclasseRelacionada(entity.taer_id); if (lstRelacionadas.Count > 0) { lstEntities.AddRange(lstRelacionadas.FindAll(p => p.tud_id != entity.tud_id)); } } lstEntities.ForEach(p => { p.tpc_id = entity.tpc_id; p.tav_id = entity.tav_id; p.tae_nome = entity.tae_nome; p.tae_descricao = entity.tae_descricao; p.tae_cargaHoraria = entity.tae_cargaHoraria; p.tdt_posicao = entity.tdt_posicao; p.IsNew = p.tae_id <= 0; }); } lstEntities.Add(entity); List <TUR_TurmaDisciplina> turmaDisciplina = TUR_TurmaDisciplinaBO.GetSelectBy_Turma(tur_id, null, GestaoEscolarUtilBO.MinutosCacheLongo); CLS_TurmaAtividadeExtraClasseDAO dao = new CLS_TurmaAtividadeExtraClasseDAO(); dao._Banco = banco; foreach (CLS_TurmaAtividadeExtraClasse atividade in lstEntities) { if (atividade.Validate()) { if (VerificaExistePorDisciplinaNomeTipoBimestre(atividade)) { throw new ValidationException(string.Format("Já existe uma atividade extraclasse com o mesmo nome e tipo para o componente curricular '{0}' no bimestre.", TUR_TurmaDisciplinaBO.GetEntity(new TUR_TurmaDisciplina { tud_id = atividade.tud_id }).tud_nome)); } decimal dis_cargaHorariaExtraClasse = 0, cargaAtividadeExtraTotal = 0; if (VerificaCargaHorariaCursoCalendario(atividade, cal_id, out dis_cargaHorariaExtraClasse, out cargaAtividadeExtraTotal)) { throw new ValidationException(string.Format("A soma de carga horária de atividades extraclasse ({0}) está acima da máxima permitida pelo componente curricular '{1}' ({2}).", cargaAtividadeExtraTotal, TUR_TurmaDisciplinaBO.GetEntity(new TUR_TurmaDisciplina { tud_id = atividade.tud_id }).tud_nome, dis_cargaHorariaExtraClasse)); } if (dao.Salvar(atividade)) { // Caso o fechamento seja automático, grava na fila de processamento. if (!isNew && fechamentoAutomatico && turmaDisciplina.Find(t => t.tud_id == atividade.tud_id).tud_tipo != (byte)TurmaDisciplinaTipo.DocenteEspecificoComplementacaoRegencia && atividade.tpc_id != ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.TIPO_PERIODO_CALENDARIO_RECESSO, ent_id)) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaFrequencia(atividade.tud_id, atividade.tpc_id, banco); } } } } return(true); } catch (Exception ex) { banco.Close(ex); throw; } finally { if (banco.ConnectionIsOpen) { banco.Close(); } } throw new ValidationException(GestaoEscolarUtilBO.ErrosValidacao(entity)); }
public static bool Delete(CLS_RelatorioPreenchimentoAlunoTurmaDisciplina entity, int rea_id) { CLS_RelatorioPreenchimentoAlunoTurmaDisciplinaDAO dao = new CLS_RelatorioPreenchimentoAlunoTurmaDisciplinaDAO(); dao._Banco.Open(IsolationLevel.ReadCommitted); try { bool sucesso = Delete(entity, dao._Banco); if (sucesso) { CLS_RelatorioAtendimento relatorioAtendimento = CLS_RelatorioAtendimentoBO.GetEntity(new CLS_RelatorioAtendimento { rea_id = rea_id }); if (relatorioAtendimento.rea_tipo == (byte)CLS_RelatorioAtendimentoTipo.RP) { ACA_CalendarioAnual calendario = ACA_CalendarioAnualBO.SelecionaPorTurma(entity.tur_id); List <MTR_MatriculaTurma> matriculasAno = MTR_MatriculaTurmaBO.GetSelectMatriculasAlunoAno(entity.alu_id, calendario.cal_ano); matriculasAno.ForEach(p => LimpaCache_AlunoPreenchimentoPorPeriodoDisciplina(entity.tpc_id, p.tur_id)); ACA_FormatoAvaliacao fav = TUR_TurmaBO.SelecionaFormatoAvaliacao(entity.tur_id, dao._Banco); if (fav != null && fav.fav_fechamentoAutomatico) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(entity.tud_id, entity.tpc_id, dao._Banco); } } else if (relatorioAtendimento.rea_tipo == (byte)CLS_RelatorioAtendimentoTipo.NAAPA) { List <AlunoFechamentoPendencia> FilaProcessamento = new List <AlunoFechamentoPendencia>(); ACA_CalendarioAnual cal = ACA_CalendarioAnualBO.SelecionaPorTurma(entity.tur_id, dao._Banco); var periodos = ACA_CalendarioPeriodoBO.SelecionaPor_Calendario(cal.cal_id, GestaoEscolarUtilBO.MinutosCacheLongo); FilaProcessamento.AddRange(TUR_TurmaDisciplinaBO.GetSelectBy_Turma(entity.tur_id, dao._Banco, GestaoEscolarUtilBO.MinutosCacheLongo) .SelectMany ( tud => periodos.Select ( tpc => new AlunoFechamentoPendencia { tud_id = tud.tud_id , tpc_id = tpc.tpc_id , afp_frequencia = true , afp_nota = true , afp_processado = 2 } ).ToList() )); if (FilaProcessamento.Any()) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(FilaProcessamento, dao._Banco); } } } return(sucesso); } catch (Exception ex) { dao._Banco.Close(ex); throw; } finally { if (dao._Banco.ConnectionIsOpen) { dao._Banco.Close(); } } }
/// <summary> /// Salva os objetos de aprendizagem da turma disciplina /// </summary> /// <param name="listObjTudDis">Lista de objetos selecionados</param> /// <param name="tud_ids">IDs da turma disciplina</param> /// <param name="cal_id">ID do calendário</param> /// <param name="banco">Transação do banco</param> public static void SalvarLista(List <CLS_ObjetoAprendizagemTurmaDisciplina> listObjTudDis, List <long> tud_ids, int cal_id, TalkDBTransaction banco = null, long tud_idRegencia = -1) { CLS_ObjetoAprendizagemTurmaDisciplinaDAO dao = new CLS_ObjetoAprendizagemTurmaDisciplinaDAO(); if (banco != null) { dao._Banco = banco; } else { dao._Banco.Open(IsolationLevel.ReadCommitted); } try { foreach (long tud_id in tud_ids) { DeletarObjTud(tud_id, dao._Banco); } foreach (CLS_ObjetoAprendizagemTurmaDisciplina oad in listObjTudDis) { Save(oad, dao._Banco); } GestaoEscolarUtilBO.LimpaCache("Cache_SelecionaTipoDisciplinaObjetosAprendizagem"); if (ACA_FormatoAvaliacaoBO.CarregarPorTud(tud_ids.First(), dao._Banco).fav_fechamentoAutomatico) { List <int> lstTpc = ACA_TipoPeriodoCalendarioBO.CarregarPeriodosAteDataAtual(cal_id, tud_ids.First()) .AsEnumerable().Select(p => new { tpc_id = Convert.ToInt32(p["tpc_id"]) }) .GroupBy(p => p.tpc_id).Select(p => p.Key).ToList(); foreach (int tpc_id in lstTpc) { foreach (long tud_id in tud_ids) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(tud_id, tpc_id, dao._Banco); } if (tud_idRegencia > 0) { CLS_AlunoFechamentoPendenciaBO.SalvarFilaPendencias(tud_idRegencia, tpc_id, dao._Banco); } } } } catch (Exception ex) { if (banco == null) { dao._Banco.Close(ex); } throw; } finally { if (banco == null) { dao._Banco.Close(); } } }