예제 #1
0
        /// <summary>
        /// Retorna a lista com a estrutura necessária para salvar a TurmaDisciplina.
        /// </summary>
        /// <param name="entTurma">Entidade da turma que será salva</param>
        /// <returns></returns>
        private List <CadastroTurmaDisciplina> RetornaTurmaDisciplina(TUR_Turma entTurma)
        {
            List <CadastroTurmaDisciplina> listaTurmaDisciplina = new List <CadastroTurmaDisciplina>();

            TUR_TurmaDisciplina entTurmaDisciplina = new TUR_TurmaDisciplina
            {
                tud_codigo                = entTurma.tur_codigo,
                tud_vagas                 = entTurma.tur_vagas,
                tud_minimoMatriculados    = entTurma.tur_minimoMatriculados,
                tud_duracao               = entTurma.tur_duracao,
                tud_cargaHorariaSemanal   = Convert.ToInt32(txtAulasSemanais.Text),
                tud_aulaForaPeriodoNormal = false,
                tud_global                = false,
                tud_nome         = RetornaNomeDisciplina(),
                tud_situacao     = (byte)TurmaDisciplinaSituacao.Ativo,
                tud_tipo         = (byte)TurmaDisciplinaTipo.DisciplinaEletivaAluno,
                tud_modo         = (byte)TurmaDisciplinaModo.Normal,
                tud_multiseriado = false,
                tud_id           = VS_tud_id,
                IsNew            = entTurma.IsNew
            };

            TUR_TurmaDisciplinaRelDisciplina entRelDis = new TUR_TurmaDisciplinaRelDisciplina
            {
                dis_id = uccDisciplina.Valor,
                tud_id = entTurmaDisciplina.tud_id
            };

            List <TUR_Turma_Docentes_Disciplina> listaDocentes = UCControleVigenciaDocentes.RetornaDadosGrid();

            listaDocentes.ForEach(p => p.entDocente.tdt_posicao = 1);

            List <TUR_TurmaDisciplinaCalendario> listaCalendario = new List <TUR_TurmaDisciplinaCalendario>();

            foreach (ListItem item in chkPeriodosCalendario.Items)
            {
                if (item.Selected)
                {
                    TUR_TurmaDisciplinaCalendario ent = new TUR_TurmaDisciplinaCalendario
                    {
                        tpc_id = Convert.ToInt32(item.Value),
                        tud_id = entTurmaDisciplina.tud_id
                    };

                    listaCalendario.Add(ent);
                }
            }

            CadastroTurmaDisciplina entCadTurmaDisciplina = new CadastroTurmaDisciplina
            {
                listaTurmaDocente         = listaDocentes,
                entTurmaCalendario        = listaCalendario,
                entTurmaDisciplina        = entTurmaDisciplina,
                entTurmaDiscRelDisciplina = entRelDis
            };

            listaTurmaDisciplina.Add(entCadTurmaDisciplina);
            return(listaTurmaDisciplina);
        }
예제 #2
0
        /// <summary>
        /// Retorna a lista com a estrutura necessária para salvar a TurmaDisciplina.
        /// </summary>
        /// <param name="entTurma">Entidade da turma que será salva</param>
        /// <returns></returns>
        private List <CadastroTurmaDisciplina> RetornaTurmaDisciplina(TUR_Turma entTurma)
        {
            List <CadastroTurmaDisciplina> listaTurmaDisciplina = new List <CadastroTurmaDisciplina>();

            TUR_TurmaDisciplina entTurmaDisciplina = new TUR_TurmaDisciplina
            {
                tud_codigo                = entTurma.tur_codigo,
                tud_vagas                 = entTurma.tur_vagas,
                tud_minimoMatriculados    = entTurma.tur_minimoMatriculados,
                tud_duracao               = entTurma.tur_duracao,
                tud_cargaHorariaSemanal   = Convert.ToInt32(txtAulasSemanais.Text),
                tud_aulaForaPeriodoNormal = false,
                tud_global                = false,
                tud_nome         = VS_ListaCurriculoDisciplina[0].dis_nome,
                tud_situacao     = (byte)TurmaDisciplinaSituacao.Ativo,
                tud_tipo         = (byte)TurmaDisciplinaTipo.Multisseriada,
                tud_modo         = (byte)TurmaDisciplinaModo.Normal,
                tud_multiseriado = false,
                tud_id           = VS_tud_id,
                IsNew            = entTurma.IsNew
            };

            List <TUR_TurmaDisciplinaRelDisciplina> lstEntTurmaDiscRelDisciplina = new List <TUR_TurmaDisciplinaRelDisciplina>();

            foreach (ACA_CurriculoDisciplina item in VS_ListaCurriculoDisciplina.Where(p => p.dis_id > 0))
            {
                TUR_TurmaDisciplinaRelDisciplina entRelDis = new TUR_TurmaDisciplinaRelDisciplina
                {
                    dis_id = item.dis_id,
                    tud_id = entTurmaDisciplina.tud_id
                };
                lstEntTurmaDiscRelDisciplina.Add(entRelDis);
            }

            List <TUR_Turma_Docentes_Disciplina> docentes = (from RepeaterItem item in rptDocentes.Items
                                                             let UCControleVigenciaDocentes = (ControleVigenciaDocentes)item.FindControl("UCControleVigenciaDocentes")
                                                                                              let posicao = Convert.ToByte(((Label)item.FindControl("lblposicao")).Text)
                                                                                                            from TUR_Turma_Docentes_Disciplina turmadocente in UCControleVigenciaDocentes.RetornaDadosGrid()
                                                                                                            let entityDocente = turmadocente.entDocente
                                                                                                                                select new TUR_Turma_Docentes_Disciplina
            {
                doc_nome = turmadocente.doc_nome
                ,
                indice = turmadocente.indice
                ,
                entDocente = new TUR_TurmaDocente
                {
                    doc_id = entityDocente.doc_id,
                    col_id = entityDocente.col_id,
                    crg_id = entityDocente.crg_id,
                    coc_id = entityDocente.coc_id,
                    tdt_vigenciaInicio = entityDocente.tdt_vigenciaInicio,
                    tdt_vigenciaFim = entityDocente.tdt_vigenciaFim,
                    tdt_id = entityDocente.tdt_id,
                    tdt_tipo = entityDocente.tdt_tipo,
                    tdt_posicao = posicao
                }
            }).ToList();

            List <TUR_TurmaDisciplinaCalendario> listaCalendario = new List <TUR_TurmaDisciplinaCalendario>();

            CadastroTurmaDisciplina entCadTurmaDisciplina = new CadastroTurmaDisciplina
            {
                listaTurmaDocente              = docentes,
                entTurmaCalendario             = listaCalendario,
                entTurmaDisciplina             = entTurmaDisciplina,
                listaEntTurmaDiscRelDisciplina = lstEntTurmaDiscRelDisciplina
            };

            listaTurmaDisciplina.Add(entCadTurmaDisciplina);
            return(listaTurmaDisciplina);
        }
예제 #3
0
        protected void UCComboDisciplina1_OnSelectedIndexChanged()
        {
            try
            {
                int cur_id = uccCursoCurriculo.Valor[0];
                int crr_id = uccCursoCurriculo.Valor[1];
                int dis_id = uccDisciplina.Valor;

                divPeriodosCurso.Visible = dis_id > 0;

                divDocente.Visible = dis_id > 0;

                if ((cur_id > 0) && (crr_id > 0) && (dis_id > 0))
                {
                    // Carregar períodos do curso que oferecem a disciplina.
                    DataTable dt = ACA_CurriculoDisciplinaBO.SelecionaPeriodosPor_Escola_EletivaAluno(cur_id, crr_id, uccFiltroEscola.Esc_ID, uccFiltroEscola.Uni_ID, dis_id);
                    chkPeriodosCurso.DataSource = dt;
                    chkPeriodosCurso.DataBind();

                    ACA_Disciplina dis = new ACA_Disciplina {
                        dis_id = dis_id
                    };
                    ACA_DisciplinaBO.GetEntity(dis);

                    lblSemPeriodoCurso.Visible = dt.Rows.Count == 0;

                    if (dt.Rows.Count == 0)
                    {
                        lblSemPeriodoCurso.Text = UtilBO.GetErroMessage("Não foi encontrado nenhum(a) " + GestaoEscolarUtilBO.nomePadraoPeriodo(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower() + " para a escola, " +
                                                                        GestaoEscolarUtilBO.nomePadraoCurso(__SessionWEB.__UsuarioWEB.Usuario.ent_id).ToLower() +
                                                                        " e " + GetGlobalResourceObject("Mensagens", "MSG_DISCIPLINA") + " selecionados.", UtilBO.TipoMensagem.Informacao);
                    }

                    // Gera Codigo da turma
                    CarregaDados_ParametroFormacao(cur_id, crr_id, dis);

                    if (String.IsNullOrEmpty(txtAulasSemanais.Text))
                    {
                        txtAulasSemanais.Text = dis.dis_cargaHorariaTeorica.ToString();
                    }

                    bool bloqueioAtribuicao = false;

                    // Carrega os docentes no controle de vigência.
                    UCControleVigenciaDocentes.CarregarDocente(
                        string.Empty,
                        1,
                        1,
                        VS_tud_id,
                        ref dtDocentes,
                        dis.tds_id,
                        uccFiltroEscola.Esc_ID,
                        uccFiltroEscola.Uni_ID,
                        false,
                        bloqueioAtribuicao,
                        ref DtVigenciasDocentes);
                }
                else
                {
                    txtCodigoTurma.Text = string.Empty;
                }
            }
            catch (ValidationException ex)
            {
                lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
            }
            catch (Exception ex)
            {
                ApplicationWEB._GravaErro(ex);
                lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar o sistema.", UtilBO.TipoMensagem.Erro);
            }
        }
예제 #4
0
        /// <summary>
        /// Carrega dados da turma na tela para alteração.
        /// </summary>
        /// <param name="tur_id">ID da turma</param>
        private void CarregarDadosAlteracao(long tur_id)
        {
            try
            {
                VS_tur_id = tur_id;

                // Carregar entidades.
                TUR_Turma entTurma = new TUR_Turma {
                    tur_id = tur_id
                };
                TUR_TurmaBO.GetEntity(entTurma);

                ESC_Escola entEscola = new ESC_Escola {
                    esc_id = entTurma.esc_id
                };
                ESC_EscolaBO.GetEntity(entEscola);

                DtVigenciasDocentes = TUR_TurmaDocenteBO.SelecionaVigenciasDocentesPorDisciplina(entTurma.tur_id);

                List <TUR_TurmaCurriculo>      listaCurriculos  = TUR_TurmaCurriculoBO.GetSelectBy_Turma(entTurma.tur_id, ApplicationWEB.AppMinutosCacheLongo);
                List <CadastroTurmaDisciplina> listaDisciplinas = TUR_TurmaDisciplinaBO.GetSelectCadastradosBy_Turma(tur_id);

                if (!ValidaDadosTurma(entTurma, entEscola, listaCurriculos, listaDisciplinas))
                {
                    return;
                }

                uccFiltroEscola.Uad_ID = entEscola.uad_idSuperior;
                uccFiltroEscola_IndexChangedUA();

                uccFiltroEscola.SelectedValueEscolas = new[] { entTurma.esc_id, entTurma.uni_id };

                uccFiltroEscola_IndexChangedUnidadeEscola();

                int cur_id = listaCurriculos[0].cur_id;
                int crr_id = listaCurriculos[0].crr_id;

                uccCursoCurriculo.Valor = new[] { cur_id, crr_id };
                UCComboCursoCurriculo1_IndexChanged();

                uccCalendario.Valor = entTurma.cal_id;
                UCComboCalendario1_IndexChanged();

                VS_tud_id = listaDisciplinas[0].entTurmaDisciplina.tud_id;
                VS_tdt_id = listaDisciplinas[0].entTurmaDocente.tdt_id;

                uccDisciplina.Valor = listaDisciplinas[0].entTurmaDiscRelDisciplina.dis_id;

                UCComboDisciplina1_OnSelectedIndexChanged();

                uccFormatoAvaliacao.CarregarFormatoPorFormatoPadraoAtivo(entTurma.fav_id);
                uccFormatoAvaliacao.Valor = entTurma.fav_id;
                UCComboFormatoAvaliacao1_IndexChanged();

                txtCodigoTurma.Text        = entTurma.tur_codigo;
                txtCodigoInep.Text         = entTurma.tur_codigoInep;
                txtCapacidade.Text         = entTurma.tur_vagas.ToString();
                txtMinimoMatriculados.Text = entTurma.tur_minimoMatriculados.ToString();

                // Carga horária semanal da disciplina.
                txtAulasSemanais.Text = listaDisciplinas[0].entTurmaDisciplina.tud_cargaHorariaSemanal.ToString();

                foreach (ListItem item in chkPeriodosCurso.Items)
                {
                    int crp_id = Convert.ToInt32(item.Value);

                    item.Selected = listaCurriculos.Exists(p => p.crp_id == crp_id);
                }

                foreach (ListItem item in chkPeriodosCalendario.Items)
                {
                    int tpc_id = Convert.ToInt32(item.Value);

                    item.Selected = listaDisciplinas[0].entTurmaCalendario.Exists(p => p.tpc_id == tpc_id);
                }

                ACA_Disciplina entDis = new ACA_Disciplina
                {
                    dis_id = listaDisciplinas[0].entTurmaDiscRelDisciplina.dis_id
                };
                ACA_DisciplinaBO.GetEntity(entDis);

                DataTable informacoesDocente =
                    ACA_DocenteBO.SelecionaPorColaboradorDocente(
                        listaDisciplinas[0].entTurmaDocente.col_id,
                        listaDisciplinas[0].entTurmaDocente.doc_id);

                bool bloqueioAtribuicao = false;

                divDocente.Visible = true;
                if (informacoesDocente.Rows.Count > 0)
                {
                    UCControleVigenciaDocentes.CarregarDocente(
                        informacoesDocente.Rows[0]["pes_nome"].ToString(),
                        1,
                        1,
                        VS_tud_id,
                        ref dtDocentes,
                        entDis.tds_id,
                        entTurma.esc_id,
                        entTurma.uni_id,
                        entTurma.tur_docenteEspecialista
                        , bloqueioAtribuicao
                        , ref DtVigenciasDocentes);
                }

                // Verifica se possui parametros de formacao
                MTR_ParametroFormacaoTurma entityFormacao = MTR_ParametroFormacaoTurmaBO.SelecionaParametroPorAnoCurso(cur_id, crr_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
                if (entityFormacao != null)
                {
                    uccTurno.CarregarTurnoPorParametroPeriodo(entityFormacao);
                }
                else
                {
                    uccTurno.CarregarTurnoPorTurnoAtivo(entTurma.trn_id);
                }

                uccTurno.Valor = entTurma.trn_id;

                if (entTurma.tur_participaRodizio)
                {
                    chkRodizio.Checked = true;
                }

                if (entTurma.tur_situacao == (byte)TUR_TurmaSituacao.Aguardando)
                {
                    ddlSituacao.Items.Add(new ListItem("Aguardando", ((byte)TUR_TurmaSituacao.Aguardando).ToString()));
                }
                ddlSituacao.SelectedValue = entTurma.tur_situacao.ToString();

                DesabilitaDadosAlteracao(entityFormacao);

                RegistraScriptConfirmacao(entTurma);
            }
            catch (ValidationException ex)
            {
                lblMessage.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
            }
            catch (Exception ex)
            {
                ApplicationWEB._GravaErro(ex);
                lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar a turma de eletiva.", UtilBO.TipoMensagem.Erro);
            }
        }