/// <summary>
/// Colocar todas as propriedades da turma na sessão.
/// </summary>
private void CarregaSessionPaginaRetorno()
{
Dictionary <string, string> listaDados = new Dictionary <string, string>();
listaDados.Add("Tud_idRetorno_ControleTurma", UCControleTurma1.VS_tud_id.ToString());
listaDados.Add("Edit_tdt_posicao", UCControleTurma1.VS_tdt_posicao.ToString());
listaDados.Add("Edit_esc_id", UCControleTurma1.VS_esc_id.ToString());
listaDados.Add("Edit_uni_id", UCControleTurma1.VS_uni_id.ToString());
listaDados.Add("Edit_tur_id", UCControleTurma1.VS_tur_id.ToString());
listaDados.Add("Edit_tud_naoLancarNota", UCControleTurma1.VS_tud_naoLancarNota.ToString());
listaDados.Add("Edit_tud_naoLancarFrequencia", UCControleTurma1.VS_tud_naoLancarFrequencia.ToString());
listaDados.Add("Edit_tur_dataEncerramento", UCControleTurma1.VS_tur_dataEncerramento.ToString());
listaDados.Add("Edit_tpc_id", UCNavegacaoTelaPeriodo.VS_tpc_id.ToString());
listaDados.Add("Edit_tpc_ordem", UCNavegacaoTelaPeriodo.VS_tpc_ordem.ToString());
listaDados.Add("Edit_cal_id", UCNavegacaoTelaPeriodo.VS_cal_id.ToString());
listaDados.Add("TextoTurmas", UCControleTurma1.LabelTurmas);
listaDados.Add("OpcaoAbaAtual", Convert.ToByte(UCNavegacaoTelaPeriodo.VS_opcaoAbaAtual).ToString());
listaDados.Add("Edit_tciIds", UCControleTurma1.VS_tciIds);
listaDados.Add("Edit_tur_tipo", UCControleTurma1.VS_tur_tipo.ToString());
listaDados.Add("Edit_tud_idAluno", UCControleTurma1.VS_tud_idAluno.ToString());
listaDados.Add("Edit_tur_idNormal", UCControleTurma1.VS_tur_idNormal.ToString());
listaDados.Add("PaginaRetorno", UCNavegacaoTelaPeriodo.VS_paginaRetorno);
Session["DadosPaginaRetorno"] = listaDados;
Session["VS_DadosTurmas"] = TUR_TurmaBO.SelecionaPorDocenteControleTurma(__SessionWEB.__UsuarioWEB.Usuario.ent_id, __SessionWEB.__UsuarioWEB.Docente.doc_id, ApplicationWEB.AppMinutosCacheCurto);
if (VS_turmaDisciplinaRelacionada.tud_id > 0)
{
Session["TudIdCompartilhada"] = VS_turmaDisciplinaRelacionada.tud_id.ToString();
}
Session["Historico"] = VS_historico;
Session["tur_tud_ids"] = UCControleTurma1.TurmasNormaisMultisseriadas.Select(p => String.Format("{0};{1}", p.tur_id, p.tud_id)).ToList();
}
/// <summary>
/// Colocar todas as propriedades da turma na sessão.
/// </summary>
private void CarregaSessionPaginaRetorno()
{
Session.Remove("tud_id");
Session.Remove("tdt_posicao");
Session.Remove("PaginaRetorno");
Session.Remove("TudIdCompartilhada");
Guid ent_id = __SessionWEB.__UsuarioWEB.Usuario.ent_id;
byte opcaoAba = Convert.ToByte(eOpcaoAbaMinhasTurmas.DiarioClasse);
List <Struct_CalendarioPeriodos> listaCalendarioPeriodo = ACA_CalendarioPeriodoBO.SelecionaPor_Calendario(Edit_cal_id, ApplicationWEB.AppMinutosCacheLongo);
Struct_CalendarioPeriodos periodo = listaCalendarioPeriodo.Where(x => (x.cap_dataInicio.Date <= DateTime.Now.Date && x.cap_dataFim.Date >= DateTime.Now.Date)).FirstOrDefault();
Dictionary <string, string> listaDados = new Dictionary <string, string>();
listaDados.Add("Edit_tdt_posicao", Edit_tdt_posicao.ToString());
listaDados.Add("Edit_esc_id", Edit_esc_id.ToString());
listaDados.Add("Edit_escola", Edit_escola.ToString());
listaDados.Add("Edit_tur_id", Edit_tur_id.ToString());
listaDados.Add("Edit_tur_codigo", Edit_tur_codigo.ToString());
listaDados.Add("Edit_tud_id", Edit_tud_id.ToString());
listaDados.Add("Edit_tud_nome", Edit_tud_nome.ToString());
listaDados.Add("Edit_cal_id", Edit_cal_id.ToString());
listaDados.Add("PaginaRetorno", "~/Academico/ControleSemanal/Busca.aspx");
Session["DadosPaginaRetorno"] = listaDados;
Session["VS_DadosTurmas"] = TUR_TurmaBO.SelecionaPorGestorMinhaEscola(ent_id, UCComboUAEscola1.Esc_ID, ApplicationWEB.AppMinutosCacheCurto);
Session["Historico"] = false;
}
/// <summary>
/// Carrega os dados na tela.
/// </summary>
public void carregaTela()
{
try
{
DataTable dtTurma = TUR_TurmaBO.SelectBY_tur_id(_VS_tur_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
int qtVagas, qtMatriculados;
TUR_TurmaBO.RetornaVagasMatriculadosPor_Turma(_VS_tur_id, out qtVagas, out qtMatriculados);
_lblTurma.Text = String.Format("Turma: <b>{0} </b><br/>", dtTurma.Rows[0]["tur_codigo"]);
_lblEscola.Text = String.Format("Escola: <b>{0} </b><br/>", dtTurma.Rows[0]["tur_escolaUnidade"]);
_lblCalendario.Text = String.Format("Calendário: <b>{0} </b><br/>", dtTurma.Rows[0]["tur_calendario"]);
_lblCurso.Text = String.Format(GestaoEscolarUtilBO.nomePadraoCurso(__SessionWEB.__UsuarioWEB.Usuario.ent_id) + ": <b>{0} </b><br/>", dtTurma.Rows[0]["tur_curso"]);
_lblTurno.Text = String.Format("Turno: <b>{0} </b><br/>", dtTurma.Rows[0]["tur_turno"]);
_lblSituacao.Text = String.Format("Situação da turma: <b>{0} </b><br/>", dtTurma.Rows[0]["tur_situacao"]);
_lblCapacidade.Text = String.Format("Capacidade da turma: <b>{0} </b><br/>", qtVagas);
_lblQtdMatriculados.Text = String.Format("Quantidade de matriculados na turma: <b>{0} </b><br/>", qtMatriculados);
PesquisaAlunos();
divLegenda.Visible = _dgvAlunos.Rows.Count > 0;
// verifica se o grupo tem permissão para alteracoes
_dgvAlunos.Columns[_dgvAlunos_ColunaNumeroChamada].Visible = false;
_dgvAlunos.AllowSorting = true;
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
_lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar alunos da turma.", UtilBO.TipoMensagem.Erro);
}
}
/// <summary>
/// Pesquisa os dados da turma.
/// </summary>
private void Pesquisar()
{
fdsSemAlunos.Visible = false;
divResultados.Visible = false;
UCAlunoEfetivacaoObservacaoGeral1.Mensagem = string.Empty;
UCAlunoEfetivacaoObservacaoGeral1.ObservacaoVisible = false;
spanMensagemSelecionarAluno.Visible = false;
#region Salvar busca realizada com os parâmetros
Dictionary <string, string> filtros = new Dictionary <string, string>();
filtros.Add("uad_idSuperior", UCComboUAEscola1.Uad_ID.ToString());
filtros.Add("esc_id", UCComboUAEscola1.Esc_ID.ToString());
filtros.Add("uni_id", UCComboUAEscola1.Uni_ID.ToString());
filtros.Add("cal_id", UCComboCalendario1.Valor.ToString());
filtros.Add("tur_id", UCComboTurma1.Valor[0].ToString());
filtros.Add("crp_idTurma", UCComboTurma1.Valor[1].ToString());
filtros.Add("ttn_id", UCComboTurma1.Valor[2].ToString());
filtros.Add("turmaExtinta", chkTurmaExtinta.Checked.ToString());
__SessionWEB.BuscaRealizada = new BuscaGestao
{
PaginaBusca = PaginaGestao.EfetivacaoGestor
,
Filtros = filtros
};
#endregion Salvar busca realizada com os parâmetros
VS_esc_id = UCComboUAEscola1.Esc_ID;
VS_tur_id = UCComboTurma1.Valor[0];
CarregarAlunosTurma(VS_tur_id);
if (rptAlunos.Items.Count > 0)
{
divResultados.Visible = true;
spanMensagemSelecionarAluno.Visible = true;
fdsSemAlunos.Visible = false;
}
else
{
divResultados.Visible = false;
fdsSemAlunos.Visible = true;
lblMensagemSemAlunos.Text = UtilBO.GetErroMessage(RetornaValorResource("lblMensagemSemAlunos.Text"), UtilBO.TipoMensagem.Informacao);
}
// Formatacao da nota numerica
string arredondamento = ACA_ParametroAcademicoBO.ParametroValorBooleanoPorEntidade(eChaveAcademico.ARREDONDAMENTO_NOTA_AVALIACAO, __SessionWEB.__UsuarioWEB.Usuario.ent_id).ToString();
ACA_FormatoAvaliacao formatoAvaliacao = TUR_TurmaBO.SelecionaFormatoAvaliacao(VS_tur_id);
ACA_EscalaAvaliacaoNumerica escalaNum = new ACA_EscalaAvaliacaoNumerica {
esa_id = formatoAvaliacao.esa_idPorDisciplina
};
ACA_EscalaAvaliacaoNumericaBO.GetEntity(escalaNum);
hdnFormatacaoNota.Value = RetornaNumeroCasasDecimais(escalaNum) + ";"
+ arredondamento.ToString().ToLower() + ";"
+ escalaNum.ean_variacao.ToString().Replace(',', '.');
//
}
private void UCComboTurmaDisciplina_IndexChanged()
{
try
{
UCCPeriodoCalendario.Valor = new[] { -1, -1 };
UCCPeriodoCalendario.PermiteEditar = false;
if (UCCTurmaDisciplina1.Valor > -1)
{
long tur_id = Convert.ToInt64(ddlTurma.SelectedValue);
TUR_Turma entTur = new TUR_Turma {
tur_id = tur_id
};
TUR_TurmaBO.GetEntity(entTur);
UCCPeriodoCalendario.CarregarPorCalendario(entTur.cal_id);
UCCPeriodoCalendario.SetarFoco();
UCCPeriodoCalendario.PermiteEditar = true;
}
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar os dados.", UtilBO.TipoMensagem.Erro);
}
}
/// <summary>
/// Registra scripts necessários para colocar a mensagem de validação no botão salvar só
/// quando alterar o combo de situação para 5-Encerrada.
/// </summary>
/// <param name="entTurma">Entidade da turma que está sendo editada</param>
private void RegistraScriptConfirmacao(TUR_Turma entTurma)
{
if (entTurma == null)
{
try
{
// Recuperar entidade da turma.
entTurma = new TUR_Turma
{
tur_id = VS_tur_id
};
TUR_TurmaBO.GetEntity(entTurma);
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar carregar o sistema.", UtilBO.TipoMensagem.Erro);
}
}
else
{
if ((!entTurma.IsNew) && (entTurma.tur_situacao == (byte)TUR_TurmaSituacao.Ativo))
{
ScriptManager sm = ScriptManager.GetCurrent(this);
if (sm != null)
{
string script = "var idDdlSituacao = '#" + ddlSituacao.ClientID + "';";
Page.ClientScript.RegisterClientScriptBlock(typeof(Page), "ids", script, true);
}
}
}
}
/// <summary>
/// Carrega o quadro de horários
/// </summary>
private void CarregarQuadro()
{
// Recupera os dados da turma
DataTable dtTurma = TUR_TurmaBO.SelectBY_tur_id(VS_tur_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
string turma = dtTurma.Rows[0]["tur_codigo"].ToString();
string escola = dtTurma.Rows[0]["tur_escolaUnidade"].ToString();
string calendario = dtTurma.Rows[0]["tur_calendario"].ToString();
string curso = dtTurma.Rows[0]["tur_curso"].ToString();
string turno = dtTurma.Rows[0]["tur_turno"].ToString();
Type objType = typeof(eDiasSemana);
FieldInfo[] propriedades = objType.GetFields();
foreach (FieldInfo objField in propriedades)
{
DescriptionAttribute[] attributes = (DescriptionAttribute[])objField.GetCustomAttributes(typeof(DescriptionAttribute), false);
if (attributes.Length > 0)
{
hdnDiasSemana.Value += CustomResource.GetGlobalResourceObject("Enumerador", attributes[0].Description) + ";";
}
}
UCComboTipoHorario.Carregar();
UCCTurmaDisciplina.CarregarTurmaDisciplina(VS_tur_id, true);
UCCTurmaDisciplina.PermiteEditar = false;
VS_lstTurmaHorario = TUR_TurmaHorarioBO.SelecionaPorTurma(VS_tur_id);
CarregarCalendario();
lblDados.Text = string.Format(CustomResource.GetGlobalResourceObject("Turma", "Turma.QuadroHorarios.lblDados.Text"), turma, escola, calendario, curso, turno);
}
protected void grvTurma_DataBound(object sender, EventArgs e)
{
UCTotalRegistros1.Total = TUR_TurmaBO.GetTotalRecords();
// Seta propriedades necessárias para ordenação nas colunas.
ConfiguraColunasOrdenacao(grvTurma, VS_Ordenacao, VS_SortDirection);
}
/// <summary>
/// Seta em cada item do combo os valores referentes a turma.
/// </summary>
private void SetaDadosAdicionaisInternos()
{
try
{
if (MostraDadosAdicionaisInternos && ddlCombo.Items.Count > 0)
{
foreach (ListItem item in ddlCombo.Items)
{
string[] idTurma = item.Value.Split(';');
if (Convert.ToInt64(idTurma[0]) > -1)
{
int qtVagas, qtMatriculados;
TUR_TurmaBO.RetornaVagasMatriculadosPor_Turma(Valor[0], out qtVagas, out qtMatriculados);
item.Text += " - Capacidade: " + qtVagas;
item.Text += " - Matriculados: " + qtMatriculados;
}
}
}
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblCapacidade.Text = "";
lblMatriculados.Text = "";
}
}
protected void grvControleVigencia_RowCommand(object sender, GridViewCommandEventArgs e)
{
if (e.CommandName == "Deletar")
{
try
{
List <TUR_Turma_Docentes_Disciplina> list = RetornaDadosGrid();
foreach (TUR_Turma_Docentes_Disciplina Item in list)
{
// Remove do cache as turmas do docente.
TUR_TurmaBO.RemoveCacheDocenteControleTurma(__SessionWEB.__UsuarioWEB.Usuario.ent_id, Item.entDocente.doc_id);
}
list.Remove(list.Find(p => p.indice == Convert.ToInt32(e.CommandArgument)));
AtualizaGrid(list);
CarregarDocenteVigente(list);
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar excluir a vigência do docente.", UtilBO.TipoMensagem.Erro);
}
}
if (e.CommandName == "Editar")
{
try
{
List <TUR_Turma_Docentes_Disciplina> list = RetornaDadosGrid();
TUR_Turma_Docentes_Disciplina entity = list.Find(p => p.indice == Convert.ToInt32(e.CommandArgument));
uccDocente.Valor = new long[] { -1, -1, -1, -1 };
uccDocente.Valor = new[] { entity.entDocente.doc_id, entity.entDocente.col_id, entity.entDocente.crg_id, entity.entDocente.coc_id };
txtVigenciaIni.Text = entity.entDocente.tdt_vigenciaInicio.ToString("dd/MM/yyyy");
txtVigenciaFim.Text = entity.entDocente.tdt_vigenciaFim != new DateTime() ? entity.entDocente.tdt_vigenciaFim.ToString("dd/MM/yyyy") : string.Empty;
lblIndice.Text = entity.indice.ToString();
lbltdt_id.Text = entity.entDocente.tdt_id.ToString();
if (uccDocente.Valor[0] == -1)
{
uccDocente._Combo.Items.Add(new ListItem(entity.doc_nome, entity.entDocente.doc_id.ToString() + ";" +
entity.entDocente.col_id.ToString() + ";" +
entity.entDocente.crg_id.ToString() + ";" +
entity.entDocente.coc_id.ToString()));
uccDocente.Valor = new[] { entity.entDocente.doc_id, entity.entDocente.col_id, entity.entDocente.crg_id, entity.entDocente.coc_id };
uccDocente.PermiteEditar = false;
}
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMessage.Text = UtilBO.GetErroMessage("Erro ao tentar editar a vigência do docente.", UtilBO.TipoMensagem.Erro);
}
}
}
/// <summary>
/// Carrega todos as turmas
/// filtrando por escola, e ano dos calendários da escola
/// </summary>
/// <param name="esc_id">ID da escola</param>
/// <param name="uni_id">ID da unidade</param>
/// <param name="cal_ano">Ano dos calendários da escola</param>
public void CarregaPorEscolaAno
(
int esc_id,
int uni_id,
int cal_ano
)
{
CarregarCombo(TUR_TurmaBO.GetSelectBy_Escola_Ano(esc_id, uni_id, cal_ano, __SessionWEB.__UsuarioWEB.Usuario.ent_id,
__SessionWEB.__UsuarioWEB.Grupo.gru_id, __SessionWEB.__UsuarioWEB.Usuario.usu_id));
}
/// <summary>
/// Carrega todos as turmas normais (tur_tipo = 1)
/// filtrando por escola, calendário e situação.
/// </summary>
/// <param name="esc_id">ID da escola</param>
/// <param name="uni_id">ID da unidade</param>
/// <param name="cal_id">ID do calendário escolar</param>
/// <param name="tur_situacao">Situação da turma.</param>
public void CarregarPorEscolaCalendarioSituacao_TurmasNormais
(
int esc_id,
int uni_id,
int cal_id,
TUR_TurmaSituacao tur_situacao
)
{
CarregarCombo(TUR_TurmaBO.GetSelectBy_Escola_Calendario_Situacao(esc_id, uni_id, cal_id, (byte)tur_situacao, ApplicationWEB.AppMinutosCacheLongo));
}
private void UCCPeriodoCalendario_IndexChanged()
{
rptAlunos.DataSource = null;
bool possuiAlunos = false;
if (UCCPeriodoCalendario.Valor[0] != -1 && UCCPeriodoCalendario.Valor[1] != -1)
{
long tur_id = Convert.ToInt64(ddlTurma.SelectedValue);
TUR_Turma tur = new TUR_Turma();
tur.tur_id = tur_id;
TUR_TurmaBO.GetEntity(tur);
TUR_TurmaDisciplina tud = new TUR_TurmaDisciplina();
tud.tud_id = UCCTurmaDisciplina1.Valor;
TUR_TurmaDisciplinaBO.GetEntity(tud);
DateTime cap_dataInicio, cap_dataFim;
ACA_CalendarioPeriodoBO.RetornaDatasPeriodoPor_FormatoAvaliacaoTurmaDisciplina(UCCPeriodoCalendario.Valor[0], string.Empty, UCCTurmaDisciplina1.Valor, tur.fav_id, out cap_dataInicio, out cap_dataFim);
DataTable dt = _VS_doc_id > 0 && VS_DisciplinaEspecial?
MTR_MatriculaTurmaDisciplinaBO.SelecionaAtivosCompensacaoAusenciaFiltroDeficiencia(tur_id, UCCTurmaDisciplina1.Valor, UCCPeriodoCalendario.Valor[0], 0, VS_tipoDocente, VS_cpa_id, false, true) :
MTR_MatriculaTurmaDisciplinaBO.SelecionaAtivosCompensacaoAusencia(UCCTurmaDisciplina1.Valor, UCCPeriodoCalendario.Valor[0], 0, VS_cpa_id, false, true);
rptAlunos.DataSource = dt;
possuiAlunos = dt.Rows.Count > 0;
rptAlunos.DataBind();
lblMessage.Text = "";
if (tud.tud_tipo == (byte)TurmaDisciplinaTipo.Experiencia &&
!TUR_TurmaDisciplinaTerritorioBO.VerificaOferecimentoExperienciaBimestre(UCCTurmaDisciplina1.Valor, UCComboCalendario.Valor, UCCPeriodoCalendario.Valor[0]))
{
mostraSalvar = false;
lblMessage.Text += UtilBO.GetErroMessage("A experiência não possui territórios vigentes no bimestre.", UtilBO.TipoMensagem.Alerta);
}
if (VS_cpa_id <= 0)
{
if (possuiAlunos)
{
btnSalvar.Visible = __SessionWEB.__UsuarioWEB.GrupoPermissao.grp_inserir && mostraSalvar;
}
else
{
btnSalvar.Visible = false;
lblMessage.Text += UtilBO.GetErroMessage("Não existem alunos com ausências para serem compensadas.", UtilBO.TipoMensagem.Alerta);
}
}
}
fdsAlunos.Visible = possuiAlunos;
}
/// <summary>
/// Carrega todos as turmas ativas
/// filtrando por escola, curso, currículo e período
/// </summary>
/// <param name="esc_id">ID da escola</param>
/// <param name="uni_id">ID da unidade</param>
/// <param name="cur_id">ID do curso</param>
/// <param name="crr_id">ID do curriculo do curso</param>
/// <param name="crp_id">ID do período do curso</param>
public void CarregarPorEscolaCurriculoPeriodo
(
int esc_id,
int uni_id,
int cur_id,
int crr_id,
int crp_id
)
{
CarregarCombo(TUR_TurmaBO.RetornaTurmasCalendario(__SessionWEB.__UsuarioWEB.Usuario.usu_id, __SessionWEB.__UsuarioWEB.Grupo.gru_id,
-1, esc_id, uni_id, -1, cur_id, crr_id, crp_id, -1, __SessionWEB.__UsuarioWEB.Usuario.ent_id, 1));
}
/// <summary>
/// Carrega todos as turmas ativas do tipo 1 (Normal) considerando cursos equivalentes
/// filtrando por escola, curso, currículo, período e ano
/// </summary>
/// <param name="esc_id">ID da escolar</param>
/// <param name="uni_id">ID da unidade escolar</param>
/// <param name="cur_id">ID do curso</param>
/// <param name="crr_id">ID do curriculo do curso</param>
/// <param name="crp_id">ID do período do curso</param>
/// <param name="cal_ano">Ano</param>
public void CarregarPorEscolaCalendarioCursoEquivalentes
(
int esc_id,
int uni_id,
int cur_id,
int crr_id,
int crp_id,
int cal_ano
)
{
CarregarCombo(TUR_TurmaBO.SelecionaPor_Escola_Calendario_CursoPeriodo_Equivalentes(__SessionWEB.__UsuarioWEB.Usuario.usu_id,
__SessionWEB.__UsuarioWEB.Grupo.gru_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id, esc_id, uni_id, cur_id, crr_id, crp_id, cal_ano));
}
/// <summary>
/// Carrega todos as turmas ativas com calendario anual existente no MomentoAno
/// filtrando por escola, curso, currículo e período
/// </summary>
/// <param name="esc_id">ID da escola</param>
/// <param name="uni_id">ID da unidade</param>
/// <param name="cur_id">ID do curso</param>
/// <param name="crr_id">ID do curriculo do curso</param>
/// <param name="crp_id">ID do período do curso</param>
public void CarregarPorEscolaCurriculoPeriodoMomentoAno
(
int esc_id,
int uni_id,
int cur_id,
int crr_id,
int crp_id
)
{
CarregarCombo(TUR_TurmaBO.GetSelectBy_Escola_Periodo_MomentoAno(esc_id, uni_id, -1, cur_id, crr_id, crp_id,
__SessionWEB.__UsuarioWEB.Usuario.ent_id, __SessionWEB.__UsuarioWEB.Usuario.usu_id,
__SessionWEB.__UsuarioWEB.Grupo.gru_id));
}
/// <summary>
/// Carrega todos as turmas do tipo 1 (Normal) e com fav_tipoLancamentoFrequencia = 3 ou 4
/// filtrando por escola, calendário, curso, currículo e currículo período
/// </summary>
/// <param name="esc_id">ID da escola.</param>
/// <param name="uni_id">ID da unidade.</param>
/// <param name="cal_id">ID do calendário.</param>
/// <param name="cur_id">ID do curso.</param>
/// <param name="crr_id">ID do currículo.</param>
/// <param name="crp_id">ID do currículo período.</param>
public void CarregarComFrequenciaMensalPorEscolaCalendarioCurriculoPeriodo
(
int esc_id
, int uni_id
, int cal_id
, int cur_id
, int crr_id
, int crp_id
)
{
CarregarCombo(TUR_TurmaBO.SelecionaPorEscolaPeriodoCalendarioComFrequenciaMensal(esc_id, uni_id, cal_id, cur_id, crr_id, crp_id,
__SessionWEB.__UsuarioWEB.Usuario.ent_id, __SessionWEB.__UsuarioWEB.Grupo.gru_id, __SessionWEB.__UsuarioWEB.Usuario.usu_id));
}
protected void _ddlTurma_DataBound(object sender, EventArgs e)
{
if (MostraDadosAdicionais && _SelecionaTurma == null)
{
divDadosTurma.Visible = true;
try
{
string tur_ids = string.Join(",",
// Busca os tur_id dos itens do combo (value dos itens).
(from ListItem item in _ddlTurma.Items
where Convert.ToInt64(item.Value.Split(';')[0]) > 0
select item.Value.Split(';')[0]
).ToArray());
// Buscar os dados adicionais pras turmas e jogar no combo, caso ele não tenha
// evento de postback setado.
DataTable dt = TUR_TurmaBO.RetornaVagasMatriculadosPor_Turma(tur_ids);
List <string> ids = new List <string>();
foreach (ListItem item in _ddlTurma.Items)
{
string tur_id = item.Value.Split(';')[0];
var x = (from DataRow dr in dt.Rows
where dr["tur_id"].ToString() == tur_id
select new
{
Capacidade = dr["Capacidade"].ToString()
,
QtMatriculasAtivas = dr["QtMatriculasAtivas"].ToString()
}
);
if (x.Count() > 0)
{
ids.Add(item.Value + ","
+ x.First().Capacidade + ","
+ x.First().QtMatriculasAtivas);
}
}
hdnQuantidadesDoCombo.Value = string.Join("|", ids.ToArray());
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblCapacidade.Text = "";
lblMatriculados.Text = "";
}
}
}
/// <summary>
/// Carrega todos as turmas
/// filtrando por escola, curso, currículo, período, ano e situação da turma
/// </summary>
/// <param name="esc_id">ID da escolar</param>
/// <param name="uni_id">ID da unidade</param>
/// <param name="cur_id">ID do curso</param>
/// <param name="crr_id">ID do curriculo do curso</param>
/// <param name="crp_id">ID do período do curso</param>
/// <param name="cal_ano">Ano</param>
/// <param name="tur_situacao">Situação da turma</param>
public void CarregarPorEscolaCurriculoCalendarioSituacao
(
int esc_id,
int uni_id,
int cur_id,
int crr_id,
int crp_id,
int cal_ano,
TUR_TurmaSituacao tur_situacao
)
{
CarregarCombo(TUR_TurmaBO.RetornaTurmasCalendario(__SessionWEB.__UsuarioWEB.Usuario.usu_id, __SessionWEB.__UsuarioWEB.Grupo.gru_id,
-1, esc_id, uni_id, -1, cur_id, crr_id, crp_id, cal_ano, __SessionWEB.__UsuarioWEB.Usuario.ent_id, (byte)tur_situacao));
}
/// <summary>
/// Carrega todos as turmas do tipo 1 (Normal)
/// filtrando por escola, curso, currículo, período e calendário
/// Sem filtrar o usuário
/// </summary>
/// <param name="esc_id">ID da escola</param>
/// <param name="uni_id">ID da unidade</param>
/// <param name="cur_id">ID do curso</param>
/// <param name="crr_id">ID do curriculo do curso</param>
/// <param name="crp_id">ID do período do curso</param>
/// <param name="cal_id">ID do calendário</param>
public void CarregaPorEscolaCurriculoPeriodoCalendario_SemUsuario
(
int esc_id,
int uni_id,
int cur_id,
int crr_id,
int crp_id,
int cal_id
)
{
CarregarCombo(TUR_TurmaBO.GetSelectBy_Escola_Periodo_Situacao(new Guid(), new Guid(), (__SessionWEB.__UsuarioWEB.Grupo.vis_id == SysVisaoID.Administracao),
esc_id, uni_id, cal_id, cur_id, crr_id, crp_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id,
0, 0, ApplicationWEB.AppMinutosCacheLongo));
}
/// <summary>
/// Carrega todos as turmas normais (tur_tipo = 1)
/// filtrando por escola, curso, currículo, período e calendário
/// </summary>
/// <param name="esc_id">ID da escola</param>
/// <param name="uni_id">ID da unidade</param>
/// <param name="cur_id">ID do curso</param>
/// <param name="crr_id">ID do curriculo do curso</param>
/// <param name="crp_id">ID do período do curso</param>
/// <param name="cal_id">ID do calendário escolar</param>
public void CarregarPorEscolaCurriculoCalendario_TurmasNormais
(
int esc_id,
int uni_id,
int cur_id,
int crr_id,
int crp_id,
int cal_id,
bool mostraEletivas = false
)
{
CarregarCombo(TUR_TurmaBO.GetSelectBy_Escola_Periodo_Situacao(__SessionWEB.__UsuarioWEB.Usuario.usu_id,
__SessionWEB.__UsuarioWEB.Grupo.gru_id, (__SessionWEB.__UsuarioWEB.Grupo.vis_id == SysVisaoID.Administracao),
esc_id, uni_id, cal_id, cur_id, crr_id, crp_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id, 1, 0, mostraEletivas,
ApplicationWEB.AppMinutosCacheLongo));
}
/// <summary>
/// Carrega as turmas eletivas do aluno
/// filtrando por escola, curso, currículo, disciplina eletiva e calendário
/// </summary>
/// <param name="esc_id">ID da escola</param>
/// <param name="uni_id">ID da unidade</param>
/// <param name="cur_id">ID do curso</param>
/// <param name="crr_id">ID do currículo do curso</param>
/// <param name="dis_id">ID da disciplina eletiva do aluno</param>
/// <param name="cal_id">ID do calendário escolar</param>
public void CarregarEletivaAlunoAtiva
(
int esc_id,
int uni_id,
int cur_id,
int crr_id,
int dis_id,
int cal_id
)
{
CarregarCombo(TUR_TurmaBO.SelecionaTurmasEletivasAluno(esc_id, uni_id, cur_id, crr_id, dis_id, cal_id,
__SessionWEB.__UsuarioWEB.Usuario.ent_id, (__SessionWEB.__UsuarioWEB.Grupo.vis_id == SysVisaoID.Administracao),
__SessionWEB.__UsuarioWEB.Grupo.gru_id, __SessionWEB.__UsuarioWEB.Usuario.usu_id));
SetaDadosAdicionaisInternos();
}
/// <summary>
/// Carrega todos as turmas do tipo 1 (Normal)
/// filtrando por escola, curso, currículo, período e situação
/// </summary>
/// <param name="esc_id">ID da escola</param>
/// <param name="uni_id">ID da unidade</param>
/// <param name="cur_id">ID do curso</param>
/// <param name="crr_id">ID do curriculo do curso</param>
/// <param name="crp_id">ID do período do curso</param>
/// <param name="tur_situacao">Situação da turma</param>
public void CarregaPorEscolaCurriculoPeriodoSituacao
(
int esc_id,
int uni_id,
int cur_id,
int crr_id,
int crp_id,
byte tur_situacao
)
{
CarregarCombo(TUR_TurmaBO.GetSelectBy_Escola_Periodo_Situacao(__SessionWEB.__UsuarioWEB.Usuario.usu_id,
__SessionWEB.__UsuarioWEB.Grupo.gru_id,
(__SessionWEB.__UsuarioWEB.Grupo.vis_id == SysVisaoID.Administracao),
esc_id, uni_id, -1, cur_id, crr_id, crp_id,
__SessionWEB.__UsuarioWEB.Usuario.ent_id, 0, tur_situacao,
ApplicationWEB.AppMinutosCacheLongo));
}
/// <summary>
/// Valida os dados necessários para realizar qualquer movimentação.
/// Dispara uma ValidationException caso haja algum problema.
/// </summary>
/// <param name="cadMov">Entidade de cadastro de movimentação</param>
/// <param name="alu">Entidade do aluno</param>
/// <param name="tmo">Entidade tipo de movimentação</param>
/// <param name="bancoGestao">Transação com banco - obrigatório</param>
private static void ValidaDadosMovimentacao(MTR_Movimentacao_Cadastro cadMov, MTR_TipoMovimentacao tmo, ACA_Aluno alu, TalkDBTransaction bancoGestao)
{
bool isValidInicioMovimentacao;
bool isValidFechamentoMovimentacao;
// Valida se está no momento configurado na movimentação.
MTR_TipoMovimentacaoBO.VerificaPeriodoValidoMovimentacao(cadMov.entMatTurAnterior,
cadMov.entAluCurAnterior,
cadMov.entMovimentacao.tmo_id,
bancoGestao,
cadMov.entMovimentacao.mov_dataRealizacao,
out isValidInicioMovimentacao,
out isValidFechamentoMovimentacao,
cadMov.listasFechamentoMatricula);
if (!isValidInicioMovimentacao)
{
throw new ValidationException("Não é possível realizar esse tipo de movimentação nesse momento do calendário escolar.");
}
if ((cadMov.entMatTurNovo != null) && (cadMov.entMatTurNovo.tur_id > 0))
{
// Verificar se a turma que o aluno vai entrar é do tipo 1-Normal.
TUR_Turma entTurmaDestino = null;
if (cadMov.listasFechamentoMatricula.listTurma != null)
{
// Se a lista de fechamento foi alimentada, buscar entidade da lista.
entTurmaDestino = cadMov.listasFechamentoMatricula.listTurma.Find(p => p.tur_id == cadMov.entMatTurNovo.tur_id);
}
if (entTurmaDestino == null)
{
entTurmaDestino = new TUR_Turma
{
tur_id = cadMov.entMatTurNovo.tur_id
};
TUR_TurmaBO.GetEntity(entTurmaDestino, bancoGestao);
}
if (entTurmaDestino.tur_tipo != (byte)TUR_TurmaTipo.Normal)
{
throw new ValidationException("Não é possível movimentar o aluno para a turma " +
entTurmaDestino.tur_codigo + ".");
}
}
}
/// <summary>
/// Carrega todos as turmas encerradas
/// filtrando por escola, curso, currículo, período e calendário
/// </summary>
/// <param name="esc_id">ID da escola</param>
/// <param name="uni_id">ID da unidade</param>
/// <param name="cur_id">ID do curso</param>
/// <param name="crr_id">ID do curriculo do curso</param>
/// <param name="crp_id">ID do período do curso</param>
/// <param name="cal_id">ID do calendário escolar</param>
public void CarregarPorEscolaCurriculoCalendarioEncerradas
(
int esc_id,
int uni_id,
int cur_id,
int crr_id,
int crp_id,
int cal_id
)
{
CarregarCombo(TUR_TurmaBO.GetSelectBy_Escola_Periodo_Situacao(__SessionWEB.__UsuarioWEB.Usuario.usu_id,
__SessionWEB.__UsuarioWEB.Grupo.gru_id,
(__SessionWEB.__UsuarioWEB.Grupo.vis_id == SysVisaoID.Administracao),
esc_id, uni_id, cal_id, cur_id, crr_id, crp_id,
__SessionWEB.__UsuarioWEB.Usuario.ent_id, 0,
(byte)TUR_TurmaSituacao.Encerrada, ApplicationWEB.AppMinutosCacheLongo));
}
/// <summary>
/// Carrega os campos de busca com a configuração padrão para uma nova busca para visão individual
/// </summary>
/// <param name="esc_id">Id da escola</param>
private void InicializaCamposBuscaVisaoIndividual(int esc_id)
{
//Carrega os campos
int posicaoDocenteCompatilhado = ACA_ParametroAcademicoBO.ParametroValorInt32PorEntidade(eChaveAcademico.POSICAO_DOCENCIA_COMPARTILHADA, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
ddlTurma.Items.Clear();
ddlTurma.DataTextField = "tur_esc_nome";
ddlTurma.Items.Insert(0, new ListItem("-- Selecione uma turma --", "-1", true));
ddlTurma.DataSource = TUR_TurmaBO.GetSelectBy_Docente_TodosTipos_Posicao(__SessionWEB.__UsuarioWEB.Usuario.ent_id, _VS_doc_id, posicaoDocenteCompatilhado, esc_id, UCComboCalendario.Valor, false, false, ApplicationWEB.AppMinutosCacheLongo)
.GroupBy(p => new { tur_id = p.tur_id, tur_esc_nome = p.tur_esc_nome }).Select(p => p.Key).ToList();
ddlTurma.DataBind();
//if (UCComboUAEscola.VisibleUA)
ddlTurma_SelectedIndexChanged(null, null);
}
protected void CarregarBoletim(long alu_id, int mtu_id)
{
try
{
string mtuId = "";
if (mtu_id > 0)
{
mtuId = Convert.ToString(mtu_id);
}
int tpc_id = 0;
MTR_MatriculaTurma matriculaTurma = MTR_MatriculaTurmaBO.GetEntity(new MTR_MatriculaTurma {
alu_id = __SessionWEB.__UsuarioWEB.alu_id, mtu_id = mtu_id
});
TUR_Turma turma = TUR_TurmaBO.GetEntity(new TUR_Turma {
tur_id = matriculaTurma.tur_id
});
DataTable dtAvaliacao = ACA_AvaliacaoBO.GetSelectBy_FormatoAvaliacao(turma.fav_id);
tpc_id = (from DataRow row in dtAvaliacao.Rows
orderby Convert.ToInt32(row["tpc_ordem"])
select Convert.ToInt32(row["tpc_id"])).FirstOrDefault();
List <ACA_AlunoBO.BoletimDadosAluno> lBoletimAluno = ACA_AlunoBO.BuscaBoletimAlunos(Convert.ToString(alu_id), mtuId, tpc_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
if (lBoletimAluno != null && lBoletimAluno.Any())
{
UCAlunoBoletimEscolar.ExibeBoletim(lBoletimAluno.FirstOrDefault());
}
else
{
throw new ValidationException("O aluno não possui dados para o boletim.");
}
}
catch (ValidationException ex)
{
lblMensagem.Text = UtilBO.GetErroMessage(ex.Message, UtilBO.TipoMensagem.Alerta);
}
catch (Exception ex)
{
ApplicationWEB._GravaErro(ex);
lblMensagem.Text = UtilBO.GetErroMessage("Erro ao exibir o Boletim Online do aluno.", UtilBO.TipoMensagem.Erro);
}
}
/// <summary>
/// Retorna se a escola de origem vai ser responsável pelo lançamento de notas
/// </summary>
/// <param name="tur_id"></param>
/// <param name="dataMovimentacao"></param>
/// <param name="ent_id"></param>
/// <returns>
/// True: Lançamento de notas será pela escola de origem
/// False: Lançamento de notas será definido pelo usuário
/// </returns>
public static bool VerificaEfetivacaoEscolaOrigem(long tur_id, DateTime dataMovimentacao, Guid ent_id)
{
TUR_Turma tur = new TUR_Turma {
tur_id = tur_id
};
TUR_TurmaBO.GetEntity(tur);
int tmo_id = MTR_TipoMovimentacaoBO.Retorna_TipoMovimentacaoId((byte)MTR_TipoMovimentacaoTipoMovimento.TransferenciaPropriaRede, ent_id);
string sPrazoDias = MTR_ParametroTipoMovimentacaoBO.SelecionaValorParametroTipoMovimentacao(tmo_id, ChaveParametroTipoMovimentacao.PrazoDiasEfetivacaoEscolaOrigem);
int PrazoDias = string.IsNullOrEmpty(sPrazoDias) ? 0 : Convert.ToInt32(sPrazoDias);
DateTime dataFimPeriodoCalendario = ACA_TipoPeriodoCalendarioBO.SelecionaDataFinalPeriodoCalendarioAtual(tur.cal_id, dataMovimentacao);
return(dataFimPeriodoCalendario != new DateTime() &&
dataFimPeriodoCalendario.AddDays(PrazoDias * -1).Date <= dataMovimentacao);
}
/// <summary>
/// Verifica se existe um parâmetro de formação de turmas eletiva cadastrada.
/// </summary>
/// <param name="cur_id">ID do curso</param>
/// <param name="crr_id">ID do currículo</param>
/// <param name="dis">ID da disciplina</param>
private void CarregaDados_ParametroFormacao(int cur_id, int crr_id, ACA_Disciplina dis)
{
if (VS_tur_id <= 0)
{
MTR_ParametroFormacaoTurma pft = MTR_ParametroFormacaoTurmaBO.SelecionaParametroPorAnoCurso(cur_id, crr_id, __SessionWEB.__UsuarioWEB.Usuario.ent_id);
if (pft != null && dis != null)
{
if (ACA_TipoMacroCampoEletivaAlunoBO.SelecionaMacroCamposAssociado(dis.dis_id).Rows.Count > 0)
{
txtCodigoTurma.Text = TUR_TurmaBO.GerarCodigoTurmaEletiva(uccFiltroEscola.Esc_ID, uccFiltroEscola.Uni_ID, cur_id, crr_id, dis.dis_id, 1, pft, null);
}
else
{
txtCodigoTurma.Text = string.Empty;
}
uccCalendario.Valor = pft.cal_id;
uccCalendario.PermiteEditar = false;
UCComboCalendario1_IndexChanged();
uccFormatoAvaliacao.Valor = pft.fav_id;
uccFormatoAvaliacao.PermiteEditar = false;
UCComboFormatoAvaliacao1_IndexChanged();
txtCapacidade.Text = Convert.ToString(pft.pft_capacidade);
txtAulasSemanais.Text = Convert.ToString(pft.pft_cargaHorariaSemanal);
uccTurno.CarregarTurnoPorParametroPeriodo(pft);
}
else
{
txtCodigoTurma.Text = txtCodigoInep.Text = string.Empty;
uccFormatoAvaliacao.Valor = -1;
UCComboFormatoAvaliacao1_IndexChanged();
txtCapacidade.Text = string.Empty;
txtAulasSemanais.Text = string.Empty;
uccTurno.CarregarTurnoPorTurnoAtivo(-1);
}
}
}
public HttpResponseMessage GetMinhasTurmasDocente()
{
try
{
var dados = TUR_TurmaBO.SelecionaPorDocenteControleTurma(__userLogged.Usuario.ent_id, __userLogged.Docente.doc_id, ApplicationWEB.AppMinutosCacheCurto);
var dadosEscolasAtivas = dados.Where(p => p.Turmas.Any(t => t.tur_situacao == (byte)TUR_TurmaSituacao.Ativo)).ToList();
if (dadosEscolasAtivas.Count == 0)
{ // se o docente não possuir nenhuma turma - exibir a mensagem informativa
var msg = CustomResource.GetGlobalResourceObject("Academico", "ControleTurma.Busca.DocenteSemTurma");
return Request.CreateResponse(HttpStatusCode.NoContent, msg);
}
var ret = dadosEscolasAtivas.Select(p => new MinhasTurmasDocente
{
calendarioId = p.cal_id,
escolaId = p.esc_id,
unidadeId = p.uni_id,
escolaNome = p.esc_nome,
Turmas = p.Turmas.Select(
t => new Turma {
codigo = t.tur_codigo,
curso = t.tur_curso,
nome = t.tud_nome,
tipoDocente = t.TipoDocencia,
turmaDisciplinaId = t.tud_id,
turmaDocentePosicao = (byte)t.tdt_posicao,
turmaId = t.tur_id,
turno = t.tur_turno,
AulasDadasVisivel = t.tud_tipo != (byte)ACA_CurriculoDisciplinaTipo.DocenciaCompartilhada
&& t.tud_tipo != (byte)ACA_CurriculoDisciplinaTipo.Experiencia,
AulasDadasOk = t.tud_tipo != (byte)ACA_CurriculoDisciplinaTipo.DocenciaCompartilhada
&& t.tud_tipo != (byte)ACA_CurriculoDisciplinaTipo.Experiencia
&& t.aulasPrevistasPreenchida
})
});
return Request.CreateResponse(HttpStatusCode.OK, ret);
}
catch (Exception ex)
{
return Request.CreateResponse(HttpStatusCode.InternalServerError, ex);
}
}
